The Tor Browser: ipc/chromium/src/base/message_pump_libevent.h@6474c204b198 (annotated)

ipc/chromium/src/base/message_pump_libevent.h@6474c204b198 (annotated)

ipc/chromium/src/base/message_pump_libevent.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #ifndef BASE_MESSAGE_PUMP_LIBEVENT_H_
 #define BASE_MESSAGE_PUMP_LIBEVENT_H_
 #include "base/message_pump.h"
 #include "base/time.h"
 #include "nsAutoPtr.h"
 // Declare structs we need from libevent.h rather than including it
 struct event_base;
 struct event;
 class nsDependentCSubstring;
 namespace base {
 // Class to monitor sockets and issue callbacks when sockets are ready for I/O
 // TODO(dkegel): add support for background file IO somehow
 class MessagePumpLibevent : public MessagePump {
  public:
   // Object returned by WatchFileDescriptor to manage further watching.
   class FileDescriptorWatcher {
     public:
      FileDescriptorWatcher();
      ~FileDescriptorWatcher();  // Implicitly calls StopWatchingFileDescriptor.
      // NOTE: These methods aren't called StartWatching()/StopWatching() to
      // avoid confusion with the win32 ObjectWatcher class.
      // Stop watching the FD, always safe to call.  No-op if there's nothing
      // to do.
      bool StopWatchingFileDescriptor();
     private:
      // Called by MessagePumpLibevent, ownership of |e| is transferred to this
      // object.
      void Init(event* e, bool is_persistent);
      // Used by MessagePumpLibevent to take ownership of event_.
      event *ReleaseEvent();
      friend class MessagePumpLibevent;
     private:
      bool is_persistent_;  // false if this event is one-shot.
      event* event_;
      DISALLOW_COPY_AND_ASSIGN(FileDescriptorWatcher);
   };
   // Used with WatchFileDescptor to asynchronously monitor the I/O readiness of
   // a File Descriptor.
   class Watcher {
    public:
     virtual ~Watcher() {}
     // Called from MessageLoop::Run when an FD can be read from/written to
     // without blocking
     virtual void OnFileCanReadWithoutBlocking(int fd) = 0;
     virtual void OnFileCanWriteWithoutBlocking(int fd) = 0;
   };
   MessagePumpLibevent();
   virtual ~MessagePumpLibevent();
   enum Mode {
     WATCH_READ = 1 << 0,
     WATCH_WRITE = 1 << 1,
     WATCH_READ_WRITE = WATCH_READ | WATCH_WRITE
   };
   // Have the current thread's message loop watch for a a situation in which
   // reading/writing to the FD can be performed without Blocking.
   // Callers must provide a preallocated FileDescriptorWatcher object which
   // can later be used to manage the Lifetime of this event.
   // If a FileDescriptorWatcher is passed in which is already attached to
   // an event, then the effect is cumulative i.e. after the call |controller|
   // will watch both the previous event and the new one.
   // If an error occurs while calling this method in a cumulative fashion, the
   // event previously attached to |controller| is aborted.
   // Returns true on success.
   // TODO(dkegel): switch to edge-triggered readiness notification
   bool WatchFileDescriptor(int fd,
                            bool persistent,
                            Mode mode,
                            FileDescriptorWatcher *controller,
                            Watcher *delegate);
   // This is analagous to FileDescriptorWatcher above, which really is
   // just a wrapper around libevent's |struct event|.  This class acts
   // as a sort of "scoped event watcher" in that it guarantees that
   // when this class is out of scope, the signal-event it wraps is
   // removed from libevent's guts.
   //
   // XXX/cjones: this isn't my favorite API, but preserving it in
   // order to match code above
   class SignalEvent {
      friend class MessagePumpLibevent;
   public:
     SignalEvent();
     ~SignalEvent();             // implicitly calls StopCatching()
     // Have libevent forget this event.
     bool StopCatching();
   private:
     void Init(event* e);
     event* ReleaseEvent();
     event* event_;
     DISALLOW_COPY_AND_ASSIGN(SignalEvent);
   };
   class SignalWatcher {
   public:
     virtual ~SignalWatcher() {}
     // Called from MessageLoop::Run when |sig| has been delivered to
     // this process
     virtual void OnSignal(int sig) = 0;
   };
   // Have the current thread's message loop catch the signal |sig|.
   // Multiple watchers can catch the same signal; they're all notified
   // upon its delivery.  Callers must provide a preallocated
   // SignalEvent object which can be used to manage the lifetime of
   // this event.  Returns true on success.
   bool CatchSignal(int sig,
                    SignalEvent* sigevent,
                    SignalWatcher* delegate);
   // MessagePump methods:
   virtual void Run(Delegate* delegate);
   virtual void Quit();
   virtual void ScheduleWork();
   virtual void ScheduleDelayedWork(const TimeTicks& delayed_work_time);
  private:
   // Risky part of constructor.  Returns true on success.
   bool Init();
   // This flag is set to false when Run should return.
   bool keep_running_;
   // This flag is set when inside Run.
   bool in_run_;
   // The time at which we should call DoDelayedWork.
   TimeTicks delayed_work_time_;
   // Libevent dispatcher.  Watches all sockets registered with it, and sends
   // readiness callbacks when a socket is ready for I/O.
   event_base* event_base_;
   // Called by libevent to tell us a registered FD can be read/written to.
   static void OnLibeventNotification(int fd, short flags,
                                      void* context);
   // Called by libevent upon receiving a signal
   static void OnLibeventSignalNotification(int sig, short flags,
                                            void* context);
   // Unix pipe used to implement ScheduleWork()
   // ... callback; called by libevent inside Run() when pipe is ready to read
   static void OnWakeup(int socket, short flags, void* context);
   // ... write end; ScheduleWork() writes a single byte to it
   int wakeup_pipe_in_;
   // ... read end; OnWakeup reads it and then breaks Run() out of its sleep
   int wakeup_pipe_out_;
   // ... libevent wrapper for read end
   event* wakeup_event_;
   DISALLOW_COPY_AND_ASSIGN(MessagePumpLibevent);
 };
 /**
  *  LineWatcher overrides OnFileCanReadWithoutBlocking. It separates the read
  *  data by mTerminator and passes each line to OnLineRead.
  */
 class LineWatcher : public MessagePumpLibevent::Watcher
 {
 public:
   LineWatcher(char aTerminator, int aBufferSize) : mReceivedIndex(0),
     mBufferSize(aBufferSize),
     mTerminator(aTerminator)
   {
     mReceiveBuffer = new char[mBufferSize];
   }
   ~LineWatcher() {}
 protected:
   /**
    * OnError will be called when |read| returns error. Derived class should
    * implement this function to handle error cases when needed.
    */
   virtual void OnError() {}
   virtual void OnLineRead(int aFd, nsDependentCSubstring& aMessage) = 0;
   virtual void OnFileCanWriteWithoutBlocking(int /* aFd */) {}
 private:
   virtual void OnFileCanReadWithoutBlocking(int aFd) MOZ_FINAL;
   nsAutoPtr<char> mReceiveBuffer;
   int mReceivedIndex;
   int mBufferSize;
   char mTerminator;
 };
 }  // namespace base
 #endif  // BASE_MESSAGE_PUMP_LIBEVENT_H_

The Tor Browser / annotate

ipc/chromium/src/base/message_pump_libevent.h@6474c204b198 (annotated)

ipc/chromium/src/base/message_pump_libevent.h