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

mojo/edk/system/master_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_MASTER_CONNECTION_MANAGER_H_
 #define MOJO_EDK_SYSTEM_MASTER_CONNECTION_MANAGER_H_
 
 #include <stdint.h>
 
 #include <unordered_map>
 
 #include "base/threading/thread.h"
-#include "mojo/edk/embedder/platform_task_runner.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
+#include "mojo/edk/platform/task_runner.h"
 #include "mojo/edk/system/connection_manager.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class TaskRunner;
 }
 
@@ skipping 22 matching lines @@
 
   // |platform_support| must be valid and remain alive until after |Shutdown()|
   // has completed.
   explicit MasterConnectionManager(embedder::PlatformSupport* platform_support);
   ~MasterConnectionManager() 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 |master_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::MasterProcessDelegate* master_process_delegate)
+  void Init(util::RefPtr<platform::TaskRunner>&& delegate_thread_task_runner,
+            embedder::MasterProcessDelegate* master_process_delegate)
       MOJO_NOT_THREAD_SAFE;
 
   // Adds a slave process and sets up/tracks a connection to that slave (using
   // |platform_handle|). |slave_info| is used by the caller/implementation of
   // |embedder::MasterProcessDelegate| to track this process. It must remain
   // alive until the delegate's |OnSlaveDisconnect()| is called with it as the
   // argument. |OnSlaveDisconnect()| will always be called for each slave,
   // assuming proper shutdown. Returns the process identifier for the
   // newly-added slave.
   ProcessIdentifier AddSlave(embedder::SlaveInfo slave_info,
@@ skipping 63 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 |master_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::MasterProcessDelegate* master_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()|.
   base::Thread private_thread_;
 
   // The following members are only accessed on |private_thread_|:
   std::unordered_map<ProcessIdentifier, Helper*> helpers_;  // Owns its values.
 
   // Note: |mutex_| is not needed in the constructor, |Init()|,
@@ skipping 20 matching lines @@
   std::unordered_map<ProcessIdentifier, ProcessConnections*> connections_
       MOJO_GUARDED_BY(mutex_);  // Owns its values.
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(MasterConnectionManager);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_MASTER_CONNECTION_MANAGER_H_