EDK: Move {platform_handle,scoped_platform_handle}.* to //mojo/edk/platform.

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/scoped_platform_handle.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
+#include "mojo/edk/platform/scoped_platform_handle.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::platform::ScopedPlatformHandle;
 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 41 matching lines @@
 
 class ChildControllerImpl;
 
 // Should be created and initialized on the main thread.
 class AppContext : public mojo::embedder::SlaveProcessDelegate {
  public:
   AppContext()
       : io_thread_("io_thread"), controller_thread_("controller_thread") {}
   ~AppContext() override {}
 
-  void Init(mojo::embedder::ScopedPlatformHandle platform_handle) {
+  void Init(ScopedPlatformHandle platform_handle) {
     // Initialize Mojo before starting any threads.
     // 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());
@@ skipping 186 matching lines @@
 
   // Make sure that we're really meant to be invoked as the child process.
 
   CHECK(command_line.HasSwitch(switches::kChildConnectionId));
   std::string child_connection_id =
       command_line.GetSwitchValueASCII(switches::kChildConnectionId);
   CHECK(!child_connection_id.empty());
 
   std::string platform_channel_info =
       command_line.GetSwitchValueASCII(switches::kPlatformChannelHandleInfo);
-  mojo::embedder::ScopedPlatformHandle platform_handle =
+  ScopedPlatformHandle platform_handle =
       mojo::embedder::PlatformChannelPair::PassClientHandleFromParentProcess(
           platform_channel_info);
   CHECK(platform_handle.is_valid());
 
   shell::AppContext app_context;
   app_context.Init(platform_handle.Pass());
 
   shell::Blocker blocker;
   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;
 }