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

mojo/edk/embedder/embedder.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 "mojo/edk/embedder/embedder.h"
 
 #include <utility>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/master_process_delegate.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/embedder/process_delegate.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_manager.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/ipc_support.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/util/ref_ptr.h"
 
+using mojo::platform::TaskRunner;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace embedder {
 
 namespace internal {
 
 // Declared in embedder_internal.h.
 PlatformSupport* g_platform_support = nullptr;
 system::Core* g_core = nullptr;
@@ skipping 20 matching lines @@
   CHECK_GT(new_counter_value, 0);
   // Use "negative" values for these IDs, so that we'll also be able to use
   // "positive" "process identifiers" (see connection_manager.h) as IDs (and
   // they won't conflict).
   return static_cast<system::ChannelId>(-new_counter_value);
 }
 
 // Note: Called on the I/O thread.
 void ShutdownIPCSupportHelper() {
   // Save these before they get nuked by |ShutdownChannelOnIOThread()|.
-  RefPtr<PlatformTaskRunner> delegate_thread_task_runner(
+  RefPtr<TaskRunner> delegate_thread_task_runner(
       internal::g_ipc_support->delegate_thread_task_runner());
   ProcessDelegate* process_delegate =
       internal::g_ipc_support->process_delegate();
 
   ShutdownIPCSupportOnIOThread();
 
   delegate_thread_task_runner->PostTask(
       base::Bind(&ProcessDelegate::OnShutdownComplete,
                  base::Unretained(process_delegate)));
 }
@@ skipping 53 matching lines @@
   if (dispatcher->GetType() != system::Dispatcher::Type::PLATFORM_HANDLE)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   *platform_handle =
       static_cast<system::PlatformHandleDispatcher*>(dispatcher.get())
           ->PassPlatformHandle();
   return MOJO_RESULT_OK;
 }
 
 void InitIPCSupport(ProcessType process_type,
-                    RefPtr<PlatformTaskRunner>&& delegate_thread_task_runner,
+                    RefPtr<TaskRunner>&& delegate_thread_task_runner,
                     ProcessDelegate* process_delegate,
-                    RefPtr<PlatformTaskRunner>&& io_thread_task_runner,
+                    RefPtr<TaskRunner>&& io_thread_task_runner,
                     ScopedPlatformHandle platform_handle) {
   // |Init()| must have already been called.
   DCHECK(internal::g_core);
   // And not |InitIPCSupport()| (without |ShutdownIPCSupport()|).
   DCHECK(!internal::g_ipc_support);
 
   internal::g_ipc_support = new system::IPCSupport(
       internal::g_platform_support, process_type,
       std::move(delegate_thread_task_runner), process_delegate,
       std::move(io_thread_task_runner), platform_handle.Pass());
@@ skipping 11 matching lines @@
   DCHECK(internal::g_ipc_support);
 
   internal::g_ipc_support->io_thread_task_runner()->PostTask(
       base::Bind(&ShutdownIPCSupportHelper));
 }
 
 ScopedMessagePipeHandle ConnectToSlave(
     SlaveInfo slave_info,
     ScopedPlatformHandle platform_handle,
     const base::Closure& did_connect_to_slave_callback,
-    RefPtr<PlatformTaskRunner>&& did_connect_to_slave_runner,
+    RefPtr<TaskRunner>&& did_connect_to_slave_runner,
     std::string* platform_connection_id,
     ChannelInfo** channel_info) {
   DCHECK(platform_connection_id);
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ConnectionIdentifier connection_id =
       internal::g_ipc_support->GenerateConnectionIdentifier();
   *platform_connection_id = connection_id.ToString();
   system::ChannelId channel_id = system::kInvalidChannelId;
   RefPtr<system::MessagePipeDispatcher> dispatcher =
       internal::g_ipc_support->ConnectToSlave(
           connection_id, slave_info, platform_handle.Pass(),
           did_connect_to_slave_callback, std::move(did_connect_to_slave_runner),
           &channel_id);
   *channel_info = new ChannelInfo(channel_id);
 
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
   return rv;
 }
 
 ScopedMessagePipeHandle ConnectToMaster(
     const std::string& platform_connection_id,
     const base::Closure& did_connect_to_master_callback,
-    RefPtr<PlatformTaskRunner>&& did_connect_to_master_runner,
+    RefPtr<TaskRunner>&& did_connect_to_master_runner,
     ChannelInfo** channel_info) {
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   bool ok = false;
   system::ConnectionIdentifier connection_id =
       system::ConnectionIdentifier::FromString(platform_connection_id, &ok);
   CHECK(ok);
 
   system::ChannelId channel_id = system::kInvalidChannelId;
@@ skipping 27 matching lines @@
 
   ScopedMessagePipeHandle rv(
       MessagePipeHandle(internal::g_core->AddDispatcher(dispatcher.get())));
   CHECK(rv.is_valid());
   return rv;
 }
 
 ScopedMessagePipeHandle CreateChannel(
     ScopedPlatformHandle platform_handle,
     const base::Callback<void(ChannelInfo*)>& did_create_channel_callback,
-    RefPtr<PlatformTaskRunner>&& did_create_channel_runner) {
+    RefPtr<TaskRunner>&& did_create_channel_runner) {
   DCHECK(platform_handle.is_valid());
   DCHECK(!did_create_channel_callback.is_null());
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
 
   system::ChannelId channel_id = MakeChannelId();
   std::unique_ptr<ChannelInfo> channel_info(new ChannelInfo(channel_id));
   RefPtr<system::MessagePipeDispatcher> dispatcher =
@@ skipping 17 matching lines @@
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
   channel_manager->ShutdownChannelOnIOThread(channel_info->channel_id);
   delete channel_info;
 }
 
 // TODO(vtl): Write tests for this.
 void DestroyChannel(ChannelInfo* channel_info,
                     const base::Closure& did_destroy_channel_callback,
-                    RefPtr<PlatformTaskRunner>&& did_destroy_channel_runner) {
+                    RefPtr<TaskRunner>&& did_destroy_channel_runner) {
   DCHECK(channel_info);
   DCHECK(channel_info->channel_id);
   DCHECK(!did_destroy_channel_callback.is_null());
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
   channel_manager->ShutdownChannel(channel_info->channel_id,
                                    did_destroy_channel_callback,
                                    std::move(did_destroy_channel_runner));
   delete channel_info;
 }
 
 void WillDestroyChannelSoon(ChannelInfo* channel_info) {
   DCHECK(channel_info);
   DCHECK(internal::g_ipc_support);
 
   system::ChannelManager* channel_manager =
       internal::g_ipc_support->channel_manager();
   channel_manager->WillShutdownChannel(channel_info->channel_id);
 }
 
 }  // namespace embedder
 }  // namespace mojo