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

mojo/edk/system/ipc_support.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/ipc_support.h"
 
 #include <type_traits>
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/master_connection_manager.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/slave_connection_manager.h"
 
+using mojo::platform::TaskRunner;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 
-IPCSupport::IPCSupport(
-    embedder::PlatformSupport* platform_support,
-    embedder::ProcessType process_type,
-    RefPtr<embedder::PlatformTaskRunner>&& delegate_thread_task_runner,
-    embedder::ProcessDelegate* process_delegate,
-    RefPtr<embedder::PlatformTaskRunner>&& io_thread_task_runner,
-    embedder::ScopedPlatformHandle platform_handle)
+IPCSupport::IPCSupport(embedder::PlatformSupport* platform_support,
+                       embedder::ProcessType process_type,
+                       RefPtr<TaskRunner>&& delegate_thread_task_runner,
+                       embedder::ProcessDelegate* process_delegate,
+                       RefPtr<TaskRunner>&& io_thread_task_runner,
+                       embedder::ScopedPlatformHandle platform_handle)
     : process_type_(process_type),
       delegate_thread_task_runner_(std::move(delegate_thread_task_runner)),
       process_delegate_(process_delegate),
       io_thread_task_runner_(std::move(io_thread_task_runner)) {
   DCHECK(delegate_thread_task_runner_);
   DCHECK(io_thread_task_runner_);
 
   switch (process_type_) {
     case embedder::ProcessType::UNINITIALIZED:
       CHECK(false);
@@ skipping 50 matching lines @@
 
 ConnectionIdentifier IPCSupport::GenerateConnectionIdentifier() {
   return connection_manager()->GenerateConnectionIdentifier();
 }
 
 RefPtr<MessagePipeDispatcher> IPCSupport::ConnectToSlave(
     const ConnectionIdentifier& connection_id,
     embedder::SlaveInfo slave_info,
     embedder::ScopedPlatformHandle platform_handle,
     const base::Closure& callback,
-    RefPtr<embedder::PlatformTaskRunner>&& callback_thread_task_runner,
+    RefPtr<TaskRunner>&& callback_thread_task_runner,
     ChannelId* channel_id) {
   DCHECK(channel_id);
 
   // We rely on |ChannelId| and |ProcessIdentifier| being identical types.
   static_assert(std::is_same<ChannelId, ProcessIdentifier>::value,
                 "ChannelId and ProcessIdentifier types don't match");
 
   embedder::ScopedPlatformHandle platform_connection_handle =
       ConnectToSlaveInternal(connection_id, slave_info, platform_handle.Pass(),
                              channel_id);
   return channel_manager()->CreateChannel(
       *channel_id, platform_connection_handle.Pass(), callback,
       std::move(callback_thread_task_runner));
 }
 
 RefPtr<MessagePipeDispatcher> IPCSupport::ConnectToMaster(
     const ConnectionIdentifier& connection_id,
     const base::Closure& callback,
-    RefPtr<embedder::PlatformTaskRunner>&& callback_thread_task_runner,
+    RefPtr<TaskRunner>&& callback_thread_task_runner,
     ChannelId* channel_id) {
   DCHECK(channel_id);
 
   static_assert(std::is_same<ChannelId, ProcessIdentifier>::value,
                 "ChannelId and ProcessIdentifier types don't match");
   embedder::ScopedPlatformHandle platform_connection_handle =
       ConnectToMasterInternal(connection_id);
   *channel_id = kMasterProcessIdentifier;
   return channel_manager()->CreateChannel(
       *channel_id, platform_connection_handle.Pass(), callback,
@@ skipping 34 matching lines @@
   CHECK_EQ(connection_manager()->Connect(connection_id, &peer_id, &is_first,
                                          &platform_connection_handle),
            ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION);
   DCHECK_EQ(peer_id, system::kMasterProcessIdentifier);
   DCHECK(platform_connection_handle.is_valid());
   return platform_connection_handle;
 }
 
 }  // namespace system
 }  // namespace mojo