EDK: Add a PlatformHandleWatcher argument to embedder::InitIPCSupport().

shell/child_main.cc

 // Copyright 2014 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.
 
 #include <unistd.h>
 
+#include <memory>
+
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
+#include "mojo/edk/base_edk/platform_handle_watcher_impl.h"
 #include "mojo/edk/base_edk/platform_task_runner_impl.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.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/util/make_unique.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/core.h"
 #include "shell/child_controller.mojom.h"
 #include "shell/child_switches.h"
 #include "shell/init.h"
 #include "shell/native_application_support.h"
 
+using mojo::platform::PlatformHandleWatcher;
 using mojo::platform::ScopedPlatformHandle;
+using mojo::platform::TaskRunner;
 using mojo::util::MakeRefCounted;
+using mojo::util::MakeUnique;
 using mojo::util::RefPtr;
 
 namespace shell {
 namespace {
 
 // Blocker ---------------------------------------------------------------------
 
 // Blocks a thread until another thread unblocks it, at which point it unblocks
 // and runs a closure provided by that thread.
 class Blocker {
@@ skipping 52 matching lines @@
     // TODO(vtl): Use make_unique when C++14 is available.
     mojo::embedder::Init(std::unique_ptr<mojo::embedder::PlatformSupport>(
         new mojo::embedder::SimplePlatformSupport()));
 
     // Create and start our I/O thread.
     base::Thread::Options io_thread_options(base::MessageLoop::TYPE_IO, 0);
     CHECK(io_thread_.StartWithOptions(io_thread_options));
     io_runner_ = MakeRefCounted<base_edk::PlatformTaskRunnerImpl>(
         io_thread_.task_runner());
     CHECK(io_runner_);
+    io_watcher_ = MakeUnique<base_edk::PlatformHandleWatcherImpl>(
+        static_cast<base::MessageLoopForIO*>(io_thread_.message_loop()));
 
     // Create and start our controller thread.
     base::Thread::Options controller_thread_options;
     controller_thread_options.message_loop_type =
         base::MessageLoop::TYPE_CUSTOM;
     controller_thread_options.message_pump_factory =
         base::Bind(&mojo::common::MessagePumpMojo::Create);
     CHECK(controller_thread_.StartWithOptions(controller_thread_options));
     controller_runner_ = MakeRefCounted<base_edk::PlatformTaskRunnerImpl>(
         controller_thread_.task_runner());
     CHECK(controller_runner_);
 
-    mojo::embedder::InitIPCSupport(mojo::embedder::ProcessType::SLAVE,
-                                   controller_runner_.Clone(), this,
-                                   io_runner_.Clone(), platform_handle.Pass());
+    mojo::embedder::InitIPCSupport(
+        mojo::embedder::ProcessType::SLAVE, controller_runner_.Clone(), this,
+        io_runner_.Clone(), io_watcher_.get(), platform_handle.Pass());
   }
 
   void Shutdown() {
     Blocker blocker;
     shutdown_unblocker_ = blocker.GetUnblocker();
     controller_runner_->PostTask([this]() { ShutdownOnControllerThread(); });
     blocker.Block();
   }
 
-  const RefPtr<mojo::platform::TaskRunner>& controller_runner() const {
+  const RefPtr<TaskRunner>& controller_runner() const {
     return controller_runner_;
   }
 
   ChildControllerImpl* controller() const { return controller_.get(); }
 
   void set_controller(scoped_ptr<ChildControllerImpl> controller) {
     controller_ = controller.Pass();
   }
 
  private:
@@ skipping 10 matching lines @@
     shutdown_unblocker_.Unblock(base::Closure());
   }
 
   void OnMasterDisconnect() override {
     // We've lost the connection to the master process. This is not recoverable.
     LOG(ERROR) << "Disconnected from master";
     _exit(1);
   }
 
   base::Thread io_thread_;
-  RefPtr<mojo::platform::TaskRunner> io_runner_;
+  RefPtr<TaskRunner> io_runner_;
+  std::unique_ptr<PlatformHandleWatcher> io_watcher_;
 
   base::Thread controller_thread_;
-  RefPtr<mojo::platform::TaskRunner> controller_runner_;
+  RefPtr<TaskRunner> controller_runner_;
 
   // Accessed only on the controller thread.
   scoped_ptr<ChildControllerImpl> controller_;
 
   // Used to unblock the main thread on shutdown.
   Blocker::Unblocker shutdown_unblocker_;
 
   DISALLOW_COPY_AND_ASSIGN(AppContext);
 };
 
@@ skipping 87 matching lines @@
 
     // We intentionally don't unload the native library as its lifetime is the
     // same as that of the process.
     base::NativeLibrary app_library = LoadNativeApplication(app_path);
     RunNativeApplication(app_library, application_request.Pass());
   }
 
   base::ThreadChecker thread_checker_;
   AppContext* const app_context_;
   Blocker::Unblocker unblocker_;
-  RefPtr<mojo::platform::TaskRunner> mojo_task_runner_;
+  RefPtr<TaskRunner> mojo_task_runner_;
   StartAppCallback on_app_complete_;
 
   mojo::embedder::ChannelInfo* channel_info_;
   mojo::Binding<ChildController> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 }  // namespace
 }  // namespace shell
@@ skipping 31 matching lines @@
         shell::ChildControllerImpl::Init(&app_context, child_connection_id,
                                          unblocker);
       });
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 
   return 0;
 }