Add //mojo/edk/platform and move platform_task_runners.h there.

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 "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_task_runner_impl.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
-#include "mojo/edk/embedder/platform_task_runner.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
+#include "mojo/edk/platform/task_runner.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::embedder::PlatformTaskRunner;
 using mojo::util::MakeRefCounted;
 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.
@@ skipping 78 matching lines @@
   }
 
   void Shutdown() {
     Blocker blocker;
     shutdown_unblocker_ = blocker.GetUnblocker();
     controller_runner_->PostTask(base::Bind(
         &AppContext::ShutdownOnControllerThread, base::Unretained(this)));
     blocker.Block();
   }
 
-  const RefPtr<PlatformTaskRunner>& controller_runner() const {
+  const RefPtr<mojo::platform::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<PlatformTaskRunner> io_runner_;
+  RefPtr<mojo::platform::TaskRunner> io_runner_;
 
   base::Thread controller_thread_;
-  RefPtr<PlatformTaskRunner> controller_runner_;
+  RefPtr<mojo::platform::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 86 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<PlatformTaskRunner> mojo_task_runner_;
+  RefPtr<mojo::platform::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 27 matching lines @@
   app_context.controller_runner()->PostTask(base::Bind(
       &shell::ChildControllerImpl::Init, base::Unretained(&app_context),
       child_connection_id, blocker.GetUnblocker()));
   // This will block, then run whatever the controller wants.
   blocker.Block();
 
   app_context.Shutdown();
 
   return 0;
 }