EDK: Add TaskRunner and PlatformHandleWatcher to RawChannel.

mojo/edk/system/slave_connection_manager.cc

 // 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.
 
 #include "mojo/edk/system/slave_connection_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 14 matching lines @@
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
 // SlaveConnectionManager ------------------------------------------------------
 
 SlaveConnectionManager::SlaveConnectionManager(
     embedder::PlatformSupport* platform_support)
     : ConnectionManager(platform_support),
-      slave_process_delegate_(),
+      slave_process_delegate_(nullptr),
+      private_thread_platform_handle_watcher_(nullptr),
       awaiting_ack_type_(NOT_AWAITING_ACK),
       ack_result_(nullptr),
       ack_peer_process_identifier_(nullptr),
       ack_is_first_(nullptr),
       ack_platform_handle_(nullptr) {}
 
 SlaveConnectionManager::~SlaveConnectionManager() {
   DCHECK(!delegate_thread_task_runner_);
   DCHECK(!slave_process_delegate_);
   DCHECK(!private_thread_);
@@ skipping 10 matching lines @@
     ScopedPlatformHandle platform_handle) {
   DCHECK(delegate_thread_task_runner);
   DCHECK(slave_process_delegate);
   DCHECK(platform_handle.is_valid());
   DCHECK(!delegate_thread_task_runner_);
   DCHECK(!slave_process_delegate_);
   DCHECK(!private_thread_);
 
   delegate_thread_task_runner_ = std::move(delegate_thread_task_runner);
   slave_process_delegate_ = slave_process_delegate;
-  // TODO(vtl): We'll need to plumb this in further.
-  PlatformHandleWatcher* platform_handle_watcher = nullptr;
   private_thread_ = platform::CreateAndStartIOThread(
-      &private_thread_task_runner_, &platform_handle_watcher);
+      &private_thread_task_runner_, &private_thread_platform_handle_watcher_);
   // TODO(vtl): With C++14 lambda captures, we'll be able to move
   // |platform_handle|.
   auto raw_platform_handle = platform_handle.release();
   private_thread_task_runner_->PostTask([this, raw_platform_handle]() {
     InitOnPrivateThread(
         ScopedPlatformHandle(PlatformHandle(raw_platform_handle)));
   });
   event_.Wait();
 }
 
 void SlaveConnectionManager::Shutdown() {
   AssertNotOnPrivateThread();
   DCHECK(slave_process_delegate_);
   DCHECK(private_thread_);
 
   // The |Stop()| will actually finish all posted tasks.
   private_thread_task_runner_->PostTask(
       [this]() { ShutdownOnPrivateThread(); });
   private_thread_->Stop();
   private_thread_.reset();
   private_thread_task_runner_ = nullptr;
+  private_thread_platform_handle_watcher_ = nullptr;
   slave_process_delegate_ = nullptr;
   delegate_thread_task_runner_ = nullptr;
 }
 
 bool SlaveConnectionManager::AllowConnect(
     const ConnectionIdentifier& connection_id) {
   AssertNotOnPrivateThread();
 
   MutexLocker locker(&mutex_);
   Result result = Result::FAILURE;
@@ skipping 40 matching lines @@
   });
   event_.Wait();
   return result;
 }
 
 void SlaveConnectionManager::InitOnPrivateThread(
     ScopedPlatformHandle platform_handle) {
   AssertOnPrivateThread();
 
   raw_channel_ = RawChannel::Create(platform_handle.Pass());
-  raw_channel_->Init(this);
+  raw_channel_->Init(private_thread_task_runner_.Clone(),
+                     private_thread_platform_handle_watcher_, this);
   event_.Signal();
 }
 
 void SlaveConnectionManager::ShutdownOnPrivateThread() {
   AssertOnPrivateThread();
 
   CHECK_EQ(awaiting_ack_type_, NOT_AWAITING_ACK);
   if (raw_channel_) {
     raw_channel_->Shutdown();
     raw_channel_.reset();
@@ skipping 185 matching lines @@
   DCHECK(!private_thread_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void SlaveConnectionManager::AssertOnPrivateThread() const {
   // This should only be called after |Init()| and before |Shutdown()|.
   DCHECK(private_thread_task_runner_->RunsTasksOnCurrentThread());
 }
 
 }  // namespace system
 }  // namespace mojo