sync_fetcher_adapter_callback.h

Go to the documentation of this file.

// Copyright 2010 Google Inc.


#ifndef NET_INSTAWEB_HTTP_PUBLIC_SYNC_FETCHER_ADAPTER_CALLBACK_H_
#define NET_INSTAWEB_HTTP_PUBLIC_SYNC_FETCHER_ADAPTER_CALLBACK_H_

#include "net/instaweb/http/public/async_fetch.h"
#include "net/instaweb/http/public/request_context.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/thread_annotations.h"
#include "pagespeed/kernel/base/thread_system.h"
#include "pagespeed/kernel/base/writer.h"

namespace net_instaweb {

class MessageHandler;

class SyncFetcherAdapterCallback : public AsyncFetch {
 public:
  SyncFetcherAdapterCallback(ThreadSystem* thread_system, Writer* writer,
                             const RequestContextPtr& request_context);


  void Release() LOCKS_EXCLUDED(mutex_);

  bool IsDone() const LOCKS_EXCLUDED(mutex_);

  bool IsDoneLockHeld() const EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  bool success() const LOCKS_EXCLUDED(mutex_);
  bool released() const LOCKS_EXCLUDED(mutex_);

  bool LockIfNotReleased() EXCLUSIVE_TRYLOCK_FUNCTION(true, mutex_);

  void Unlock() UNLOCK_FUNCTION(mutex_);

  void TimedWait(int64 timeout_ms) EXCLUSIVE_LOCKS_REQUIRED(mutex_);

 protected:
  virtual void HandleDone(bool success) LOCKS_EXCLUDED(mutex_);
  virtual bool HandleWrite(const StringPiece& content,
                           MessageHandler* handler) {
    return writer_->Write(content, handler);
  }
  virtual bool HandleFlush(MessageHandler* handler) {
    return writer_->Flush(handler);
  }
  virtual void HandleHeadersComplete() {
  }

 private:
  class ProtectedWriter : public Writer {
   public:
    ProtectedWriter(SyncFetcherAdapterCallback* callback, Writer* orig_writer)
        : callback_(callback), orig_writer_(orig_writer) {}

    virtual bool Write(const StringPiece& buf, MessageHandler* handler)
        LOCKS_EXCLUDED(callback_->mutex_);
    virtual bool Flush(MessageHandler* handler)
        LOCKS_EXCLUDED(callback_->mutex_);

   private:
    SyncFetcherAdapterCallback* callback_;
    Writer* orig_writer_ GUARDED_BY(callback_->mutex_);

    
  };
  virtual ~SyncFetcherAdapterCallback();

  scoped_ptr<ThreadSystem::CondvarCapableMutex> mutex_;
  scoped_ptr<ThreadSystem::Condvar> cond_;

  bool done_ GUARDED_BY(mutex_);
  bool success_ GUARDED_BY(mutex_);
  bool released_ GUARDED_BY(mutex_);
  scoped_ptr<Writer> writer_;

  
};

}  

#endif