EDK: Add TaskRunner and PlatformHandleWatcher to RawChannel.

mojo/edk/system/raw_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_RAW_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_RAW_CHANNEL_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "mojo/edk/platform/platform_handle.h"
+#include "mojo/edk/platform/platform_handle_watcher.h"
 #include "mojo/edk/platform/scoped_platform_handle.h"
+#include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/util/mutex.h"
+#include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class MessageLoopForIO;
 }
 
 namespace mojo {
 namespace system {
 
@@ skipping 58 matching lines @@
   // Static factory method. |handle| should be a handle to a
   // (platform-appropriate) bidirectional communication channel (e.g., a socket
   // on POSIX, a named pipe on Windows).
   static std::unique_ptr<RawChannel> Create(
       platform::ScopedPlatformHandle handle);
 
   // This must be called (on an I/O thread) before this object is used. Does
   // *not* take ownership of |delegate|. Both the I/O thread and |delegate| must
   // remain alive until |Shutdown()| is called (unless this fails); |delegate|
   // will no longer be used after |Shutdown()|.
-  void Init(Delegate* delegate) MOJO_NOT_THREAD_SAFE;
+  void Init(util::RefPtr<platform::TaskRunner>&& io_task_runner,
+            platform::PlatformHandleWatcher* io_watcher,
+            Delegate* delegate) MOJO_NOT_THREAD_SAFE;
 
   // This must be called (on the I/O thread) before this object is destroyed.
   void Shutdown() MOJO_NOT_THREAD_SAFE;
 
   // Writes the given message (or schedules it to be written). |message| must
   // have no |Dispatcher|s still attached (i.e.,
   // |SerializeAndCloseDispatchers()| should have been called). This method is
   // thread-safe and may be called from any thread. Returns true on success.
   bool WriteMessage(std::unique_ptr<MessageInTransit> message);
 
@@ skipping 203 matching lines @@
   // write operation to run later if there is more to write. If |io_result| is
   // failure or any other error occurs, cancels pending writes and returns
   // false. May only be called if |write_stopped_| is false.
   bool OnWriteCompletedNoLock(IOResult io_result,
                               size_t platform_handles_written,
                               size_t bytes_written)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(write_mutex_);
 
   // Set in |Init()| and never changed (hence usable on any thread without
   // locking):
+  util::RefPtr<platform::TaskRunner> io_task_runner_;
+  // TODO(vtl): Remove this, once RawChannelPosix has been converted.
   base::MessageLoopForIO* message_loop_for_io_;
 
   // Only used on the I/O thread:
+  platform::PlatformHandleWatcher* io_watcher_;
   Delegate* delegate_;
   bool* set_on_shutdown_;
   std::unique_ptr<ReadBuffer> read_buffer_;
 
   util::Mutex write_mutex_;  // Protects the following members.
   bool write_stopped_ MOJO_GUARDED_BY(write_mutex_);
   std::unique_ptr<WriteBuffer> write_buffer_ MOJO_GUARDED_BY(write_mutex_);
 
   // This is used for posting tasks from write threads to the I/O thread. The
   // weak pointers it produces are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_
       MOJO_GUARDED_BY(write_mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_RAW_CHANNEL_H_