EDK: Add PlatformHandleWatcher to IPCSupport class.

mojo/edk/system/ipc_support.h

 // Copyright 2015 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_IPC_SUPPORT_H_
 #define MOJO_EDK_SYSTEM_IPC_SUPPORT_H_
 
 #include <functional>
 #include <memory>
 
 #include "base/gtest_prod_util.h"
 #include "mojo/edk/embedder/process_type.h"
 #include "mojo/edk/embedder/slave_info.h"
 #include "mojo/edk/platform/scoped_platform_handle.h"
 #include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/channel_id.h"
 #include "mojo/edk/system/connection_identifier.h"
 #include "mojo/edk/system/process_identifier.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 namespace embedder {
 class PlatformSupport;
 class ProcessDelegate;
 }
 
+namespace platform {
+class PlatformHandleWatcher;
+}
+
 namespace system {
 
 class ChannelManager;
 class ConnectionManager;
 class MessagePipeDispatcher;
 
 // This test (and its helper function) need to be friended.
 FORWARD_DECLARE_TEST(IPCSupportTest, MasterSlaveInternal);
 FORWARD_DECLARE_TEST(IPCSupportTest, MultiprocessMasterSlaveInternal);
 void MultiprocessMasterSlaveInternalTestChildTest();
@@ skipping 20 matching lines @@
   // must match the process type. |platform_handle| is only used for slave
   // processes.
   //
   // All the (pointer) arguments must remain alive (and, in the case of task
   // runners, continue to process tasks) until |ShutdownOnIOThread()| has been
   // called.
   IPCSupport(embedder::PlatformSupport* platform_support,
              embedder::ProcessType process_type,
              util::RefPtr<platform::TaskRunner>&& delegate_thread_task_runner,
              embedder::ProcessDelegate* process_delegate,
-             util::RefPtr<platform::TaskRunner>&& io_thread_task_runner,
+             util::RefPtr<platform::TaskRunner>&& io_task_runner,
+             platform::PlatformHandleWatcher* io_watcher,
              platform::ScopedPlatformHandle platform_handle);
   // Note: This object must be shut down before destruction (see
   // |ShutdownOnIOThread()|).
   ~IPCSupport();
 
   // This must be called (exactly once) on the I/O thread before this object is
   // destroyed (which may happen on any thread). Note: This does *not* call the
   // process delegate's |OnShutdownComplete()|.
   void ShutdownOnIOThread();
 
@@ skipping 42 matching lines @@
       ChannelId* channel_id);
 
   embedder::ProcessType process_type() const { return process_type_; }
   embedder::ProcessDelegate* process_delegate() const {
     return process_delegate_;
   }
   const util::RefPtr<platform::TaskRunner>& delegate_thread_task_runner()
       const {
     return delegate_thread_task_runner_;
   }
-  const util::RefPtr<platform::TaskRunner>& io_thread_task_runner() const {
-    return io_thread_task_runner_;
+  const util::RefPtr<platform::TaskRunner>& io_task_runner() const {
+    return io_task_runner_;
   }
   // TODO(vtl): The things that use the following should probably be moved into
   // this class.
   ChannelManager* channel_manager() const { return channel_manager_.get(); }
 
  private:
   // These test |ConnectToSlaveInternal()| and |ConnectToMasterInternal()|.
   FRIEND_TEST_ALL_PREFIXES(IPCSupportTest, MasterSlaveInternal);
   FRIEND_TEST_ALL_PREFIXES(IPCSupportTest, MultiprocessMasterSlaveInternal);
   friend void MultiprocessMasterSlaveInternalTestChildTest();
@@ skipping 17 matching lines @@
       const ConnectionIdentifier& connection_id);
 
   ConnectionManager* connection_manager() const {
     return connection_manager_.get();
   }
 
   // These are all set on construction and reset by |ShutdownOnIOThread()|.
   embedder::ProcessType process_type_;
   util::RefPtr<platform::TaskRunner> delegate_thread_task_runner_;
   embedder::ProcessDelegate* process_delegate_;
-  util::RefPtr<platform::TaskRunner> io_thread_task_runner_;
+  util::RefPtr<platform::TaskRunner> io_task_runner_;
+  platform::PlatformHandleWatcher* io_watcher_;
 
   std::unique_ptr<ConnectionManager> connection_manager_;
   std::unique_ptr<ChannelManager> channel_manager_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(IPCSupport);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_IPC_SUPPORT_H_