OLD | NEW |
(Empty) | |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef MOJO_COMMON_MESSAGE_PUMP_MOJO_H_ |
| 6 #define MOJO_COMMON_MESSAGE_PUMP_MOJO_H_ |
| 7 |
| 8 #include <map> |
| 9 |
| 10 #include "base/macros.h" |
| 11 #include "base/memory/scoped_ptr.h" |
| 12 #include "base/message_loop/message_pump.h" |
| 13 #include "base/observer_list.h" |
| 14 #include "base/synchronization/lock.h" |
| 15 #include "base/time/time.h" |
| 16 #include "mojo/common/mojo_common_export.h" |
| 17 #include "third_party/mojo/src/mojo/public/cpp/system/core.h" |
| 18 |
| 19 namespace mojo { |
| 20 namespace common { |
| 21 |
| 22 class MessagePumpMojoHandler; |
| 23 |
| 24 // Mojo implementation of MessagePump. |
| 25 class MOJO_COMMON_EXPORT MessagePumpMojo : public base::MessagePump { |
| 26 public: |
| 27 class Observer { |
| 28 public: |
| 29 Observer() {} |
| 30 |
| 31 virtual void WillSignalHandler() = 0; |
| 32 virtual void DidSignalHandler() = 0; |
| 33 |
| 34 protected: |
| 35 virtual ~Observer() {} |
| 36 }; |
| 37 |
| 38 MessagePumpMojo(); |
| 39 ~MessagePumpMojo() override; |
| 40 |
| 41 // Static factory function (for using with |base::Thread::Options|, wrapped |
| 42 // using |base::Bind()|). |
| 43 static scoped_ptr<base::MessagePump> Create(); |
| 44 |
| 45 // Returns the MessagePumpMojo instance of the current thread, if it exists. |
| 46 static MessagePumpMojo* current(); |
| 47 |
| 48 static bool IsCurrent() { return !!current(); } |
| 49 |
| 50 // Registers a MessagePumpMojoHandler for the specified handle. Only one |
| 51 // handler can be registered for a specified handle. |
| 52 // NOTE: a value of 0 for |deadline| indicates an indefinite timeout. |
| 53 void AddHandler(MessagePumpMojoHandler* handler, |
| 54 const Handle& handle, |
| 55 MojoHandleSignals wait_signals, |
| 56 base::TimeTicks deadline); |
| 57 |
| 58 void RemoveHandler(const Handle& handle); |
| 59 |
| 60 void AddObserver(Observer*); |
| 61 void RemoveObserver(Observer*); |
| 62 |
| 63 // MessagePump: |
| 64 void Run(Delegate* delegate) override; |
| 65 void Quit() override; |
| 66 void ScheduleWork() override; |
| 67 void ScheduleDelayedWork(const base::TimeTicks& delayed_work_time) override; |
| 68 |
| 69 private: |
| 70 struct RunState; |
| 71 struct WaitState; |
| 72 |
| 73 // Contains the data needed to track a request to AddHandler(). |
| 74 struct Handler { |
| 75 Handler() : handler(NULL), wait_signals(MOJO_HANDLE_SIGNAL_NONE), id(0) {} |
| 76 |
| 77 MessagePumpMojoHandler* handler; |
| 78 MojoHandleSignals wait_signals; |
| 79 base::TimeTicks deadline; |
| 80 // See description of |MessagePumpMojo::next_handler_id_| for details. |
| 81 int id; |
| 82 }; |
| 83 |
| 84 typedef std::map<Handle, Handler> HandleToHandler; |
| 85 |
| 86 // Implementation of Run(). |
| 87 void DoRunLoop(RunState* run_state, Delegate* delegate); |
| 88 |
| 89 // Services the set of handles ready. If |block| is true this waits for a |
| 90 // handle to become ready, otherwise this does not block. Returns |true| if a |
| 91 // handle has become ready, |false| otherwise. |
| 92 bool DoInternalWork(const RunState& run_state, bool block); |
| 93 |
| 94 // Removes the given invalid handle. This is called if MojoWaitMany finds an |
| 95 // invalid handle. |
| 96 void RemoveInvalidHandle(const WaitState& wait_state, |
| 97 MojoResult result, |
| 98 uint32_t result_index); |
| 99 |
| 100 void SignalControlPipe(const RunState& run_state); |
| 101 |
| 102 WaitState GetWaitState(const RunState& run_state) const; |
| 103 |
| 104 // Returns the deadline for the call to MojoWaitMany(). |
| 105 MojoDeadline GetDeadlineForWait(const RunState& run_state) const; |
| 106 |
| 107 void WillSignalHandler(); |
| 108 void DidSignalHandler(); |
| 109 |
| 110 // If non-NULL we're running (inside Run()). Member is reference to value on |
| 111 // stack. |
| 112 RunState* run_state_; |
| 113 |
| 114 // Lock for accessing |run_state_|. In general the only method that we have to |
| 115 // worry about is ScheduleWork(). All other methods are invoked on the same |
| 116 // thread. |
| 117 base::Lock run_state_lock_; |
| 118 |
| 119 HandleToHandler handlers_; |
| 120 |
| 121 // An ever increasing value assigned to each Handler::id. Used to detect |
| 122 // uniqueness while notifying. That is, while notifying expired timers we copy |
| 123 // |handlers_| and only notify handlers whose id match. If the id does not |
| 124 // match it means the handler was removed then added so that we shouldn't |
| 125 // notify it. |
| 126 int next_handler_id_; |
| 127 |
| 128 base::ObserverList<Observer> observers_; |
| 129 |
| 130 DISALLOW_COPY_AND_ASSIGN(MessagePumpMojo); |
| 131 }; |
| 132 |
| 133 } // namespace common |
| 134 } // namespace mojo |
| 135 |
| 136 #endif // MOJO_COMMON_MESSAGE_PUMP_MOJO_H_ |
OLD | NEW |