EDK: Add PlatformHandleWatcher to Channel (and ChannelManager) classes.

mojo/edk/system/channel.h

 // Copyright 2013 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 MOJO_EDK_SYSTEM_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <unordered_map>
 
 #include "mojo/edk/platform/scoped_platform_handle.h"
+#include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/ref_counted.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/edk/util/thread_checker.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 namespace embedder {
 class PlatformSupport;
 }
 
+namespace platform {
+class PlatformHandleWatcher;
+}
+
 namespace system {
 
 class ChannelEndpointClient;
 class ChannelManager;
 class MessageInTransitQueue;
 
-// This class is mostly thread-safe. It must be created on an I/O thread.
-// |Init()| must be called on that same thread before it becomes thread-safe (in
-// particular, before references are given to any other thread) and |Shutdown()|
-// must be called on that same thread before destruction. Its public methods are
-// otherwise thread-safe. (Many private methods are restricted to the creation
-// thread.) It may be destroyed on any thread, in the sense that the last
-// reference to it may be released on any thread, with the proviso that
-// |Shutdown()| must have been called first (so the pattern is that a "main"
-// reference is kept on its creation thread and is released after |Shutdown()|
-// is called, but other threads may have temporarily "dangling" references).
+// This class is mostly thread-safe. It may be created and destroyed on any
+// thread. However, |Init()| must be called on an I/O thread before other
+// methods are called. Before destruction, |Shutdown()| must be called on that
+// same thread, after which other methods may not be called. Subject to these
+// restrictions, its public methods are otherwise thread-safe. (Many private
+// methods are restricted to the I/O thread.)
 //
 // Note the lock order (in order of allowable acquisition):
 // |ChannelEndpointClient| (e.g., |MessagePipe|), |ChannelEndpoint|, |Channel|.
 // Thus |Channel| may not call into |ChannelEndpoint| with |Channel|'s lock
 // held.
 class Channel final : public util::RefCountedThreadSafe<Channel>,
                       public RawChannel::Delegate {
  public:
   // Note: Use |util::MakeRefCounted<Channel>()|.
 
-  // This must be called on the creation thread before any other methods are
-  // called, and before references to this object are given to any other
-  // threads. |raw_channel| should be uninitialized.
-  void Init(std::unique_ptr<RawChannel> raw_channel) MOJO_NOT_THREAD_SAFE;
+  // This must be called on an I/O thread before any other methods are called.
+  // |io_task_runner| and |io_watcher| should be for this thread. |raw_channel|
+  // should be uninitialized.
+  void Init(util::RefPtr<platform::TaskRunner>&& io_task_runner,
+            platform::PlatformHandleWatcher* io_watcher,
+            std::unique_ptr<RawChannel> raw_channel) MOJO_NOT_THREAD_SAFE;
 
   // Sets the channel manager associated with this channel. This should be set
   // at most once and only called before |WillShutdownSoon()| (and
   // |Shutdown()|). (This is called by the channel manager when adding a
   // channel; this should not be called before the channel is managed by the
   // channel manager.)
   void SetChannelManager(ChannelManager* channel_manager);
 
   // This must be called on the creation thread before destruction (which can
   // happen on any thread).
@@ skipping 208 matching lines @@
   // if/when we wrap).
   RemoteChannelEndpointIdGenerator remote_id_generator_ MOJO_GUARDED_BY(mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_