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/memory/scoped_ptr.h" 11 #include "base/message_loop/message_pump.h" 12 #include "base/synchronization/lock.h" 13 #include "base/time/time.h" 14 #include "mojo/common/mojo_common_export.h" 15 #include "mojo/public/cpp/system/core.h" 16 17 namespace mojo { 18 namespace common { 19 20 class MessagePumpMojoHandler; 21 22 // Mojo implementation of MessagePump. 23 class MOJO_COMMON_EXPORT MessagePumpMojo : public base::MessagePump { 24 public: 25 MessagePumpMojo(); 26 virtual ~MessagePumpMojo(); 27 28 // Static factory function (for using with |base::Thread::Options|, wrapped 29 // using |base::Bind()|). 30 static scoped_ptr<base::MessagePump> Create(); 31 32 // Registers a MessagePumpMojoHandler for the specified handle. Only one 33 // handler can be registered for a specified handle. 34 void AddHandler(MessagePumpMojoHandler* handler, 35 const Handle& handle, 36 MojoHandleSignals wait_signals, 37 base::TimeTicks deadline); 38 39 void RemoveHandler(const Handle& handle); 40 41 // MessagePump: 42 virtual void Run(Delegate* delegate) OVERRIDE; 43 virtual void Quit() OVERRIDE; 44 virtual void ScheduleWork() OVERRIDE; 45 virtual void ScheduleDelayedWork( 46 const base::TimeTicks& delayed_work_time) OVERRIDE; 47 48 private: 49 struct RunState; 50 struct WaitState; 51 52 // Contains the data needed to track a request to AddHandler(). 53 struct Handler { HandlerHandler54 Handler() : handler(NULL), wait_signals(MOJO_HANDLE_SIGNAL_NONE), id(0) {} 55 56 MessagePumpMojoHandler* handler; 57 MojoHandleSignals wait_signals; 58 base::TimeTicks deadline; 59 // See description of |MessagePumpMojo::next_handler_id_| for details. 60 int id; 61 }; 62 63 typedef std::map<Handle, Handler> HandleToHandler; 64 65 // Implementation of Run(). 66 void DoRunLoop(RunState* run_state, Delegate* delegate); 67 68 // Services the set of handles ready. If |block| is true this waits for a 69 // handle to become ready, otherwise this does not block. 70 void DoInternalWork(const RunState& run_state, bool block); 71 72 // Removes the first invalid handle. This is called if MojoWaitMany finds an 73 // invalid handle. 74 void RemoveFirstInvalidHandle(const WaitState& wait_state); 75 76 void SignalControlPipe(const RunState& run_state); 77 78 WaitState GetWaitState(const RunState& run_state) const; 79 80 // Returns the deadline for the call to MojoWaitMany(). 81 MojoDeadline GetDeadlineForWait(const RunState& run_state) const; 82 83 // If non-NULL we're running (inside Run()). Member is reference to value on 84 // stack. 85 RunState* run_state_; 86 87 // Lock for accessing |run_state_|. In general the only method that we have to 88 // worry about is ScheduleWork(). All other methods are invoked on the same 89 // thread. 90 base::Lock run_state_lock_; 91 92 HandleToHandler handlers_; 93 94 // An ever increasing value assigned to each Handler::id. Used to detect 95 // uniqueness while notifying. That is, while notifying expired timers we copy 96 // |handlers_| and only notify handlers whose id match. If the id does not 97 // match it means the handler was removed then added so that we shouldn't 98 // notify it. 99 int next_handler_id_; 100 101 DISALLOW_COPY_AND_ASSIGN(MessagePumpMojo); 102 }; 103 104 } // namespace common 105 } // namespace mojo 106 107 #endif // MOJO_COMMON_MESSAGE_PUMP_MOJO_H_ 108