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

mojo/edk/system/slave_connection_manager.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_SLAVE_CONNECTION_MANAGER_H_
 #define MOJO_EDK_SYSTEM_SLAVE_CONNECTION_MANAGER_H_
 
 #include <memory>
 
 #include "base/threading/thread.h"
-#include "mojo/edk/embedder/platform_task_runner.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/embedder/slave_process_delegate.h"
+#include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/connection_manager.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/waitable_event.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class TaskRunner;
 }
@@ skipping 19 matching lines @@
 
   // |platform_support| must be valid and remain alive until after |Shutdown()|
   // has completed.
   explicit SlaveConnectionManager(embedder::PlatformSupport* platform_support);
   ~SlaveConnectionManager() override;
 
   // No other methods may be called until after this has been called.
   // |delegate_thread_task_runner| should be the task runner for the "delegate
   // thread", on which |slave_process_delegate|'s methods will be called. Both
   // must stay alive at least until after |Shutdown()| has been called.
-  void Init(
-      util::RefPtr<embedder::PlatformTaskRunner>&& delegate_thread_task_runner,
-      embedder::SlaveProcessDelegate* slave_process_delegate,
-      embedder::ScopedPlatformHandle platform_handle);
+  void Init(util::RefPtr<platform::TaskRunner>&& delegate_thread_task_runner,
+            embedder::SlaveProcessDelegate* slave_process_delegate,
+            embedder::ScopedPlatformHandle platform_handle);
 
   // |ConnectionManager| methods:
   void Shutdown() override;
   bool AllowConnect(const ConnectionIdentifier& connection_id) override;
   bool CancelConnect(const ConnectionIdentifier& connection_id) override;
   Result Connect(const ConnectionIdentifier& connection_id,
                  ProcessIdentifier* peer_process_identifier,
                  bool* is_first,
                  embedder::ScopedPlatformHandle* platform_handle) override;
 
@@ skipping 24 matching lines @@
 
   // Asserts that the current thread is |private_thread_| (no-op if DCHECKs are
   // not enabled). This should only be called while |private_thread_| is alive
   // (i.e., after |Init()| but before |Shutdown()|).
   void AssertOnPrivateThread() const;
 
   // These are set in |Init()| before |private_thread_| exists and only cleared
   // in |Shutdown()| after |private_thread_| is dead. Thus it's safe to "use" on
   // |private_thread_|. (Note that |slave_process_delegate_| may only be called
   // from the delegate thread.)
-  util::RefPtr<embedder::PlatformTaskRunner> delegate_thread_task_runner_;
+  util::RefPtr<platform::TaskRunner> delegate_thread_task_runner_;
   embedder::SlaveProcessDelegate* slave_process_delegate_;
 
   // This is a private I/O thread on which this class does the bulk of its work.
   // It is started in |Init()| and terminated in |Shutdown()|.
   // TODO(vtl): This isn't really necessary.
   base::Thread private_thread_;
 
   // Only accessed on |private_thread_|:
   std::unique_ptr<RawChannel> raw_channel_;
   enum AwaitingAckType {
@@ skipping 38 matching lines @@
   util::Mutex mutex_;
   util::AutoResetWaitableEvent event_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(SlaveConnectionManager);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_SLAVE_CONNECTION_MANAGER_H_