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

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/scoped_platform_handle.h"
+#include "mojo/edk/platform/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 35 matching lines @@
       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,
-                             embedder::ScopedPlatformHandle platform_handle);
+                             platform::ScopedPlatformHandle platform_handle);
 
   // Like |AddSlave()|, but allows a connection to be bootstrapped: both the
   // master and slave may call |Connect()| with |connection_id| immediately (as
   // if both had already called |AllowConnect()|). |connection_id| must be
   // unique (i.e., not previously used).
   // TODO(vtl): Is |AddSlave()| really needed? (It's probably mostly useful for
   // tests.)
   ProcessIdentifier AddSlaveAndBootstrap(
       embedder::SlaveInfo slave_info,
-      embedder::ScopedPlatformHandle platform_handle,
+      platform::ScopedPlatformHandle platform_handle,
       const ConnectionIdentifier& connection_id);
 
   // |ConnectionManager| methods:
   void Shutdown() override MOJO_NOT_THREAD_SAFE;
   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;
+                 platform::ScopedPlatformHandle* platform_handle) override;
 
  private:
   class Helper;
 
   // These should be thread-safe and may be called on any thread, including
   // |private_thread_|:
   bool AllowConnectImpl(ProcessIdentifier process_identifier,
                         const ConnectionIdentifier& connection_id);
   bool CancelConnectImpl(ProcessIdentifier process_identifier,
                          const ConnectionIdentifier& connection_id);
   Result ConnectImpl(ProcessIdentifier process_identifier,
                      const ConnectionIdentifier& connection_id,
                      ProcessIdentifier* peer_process_identifier,
                      bool* is_first,
-                     embedder::ScopedPlatformHandle* platform_handle);
+                     platform::ScopedPlatformHandle* platform_handle);
 
   // Helper for |ConnectImpl()|. This is called when the two process identifiers
   // are known (and known to be valid), and all that remains is to determine the
   // |Result| and provide a platform handle if appropriate. (This will never
   // return |Result::FAILURE|.)
   Result ConnectImplHelperNoLock(
       ProcessIdentifier process_identifier,
       ProcessIdentifier peer_process_identifier,
-      embedder::ScopedPlatformHandle* platform_handle)
+      platform::ScopedPlatformHandle* platform_handle)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
   // These should only be called on |private_thread_|:
   void ShutdownOnPrivateThread() MOJO_NOT_THREAD_SAFE;
   // Signals |*event| on completion.
   void AddSlaveOnPrivateThread(embedder::SlaveInfo slave_info,
-                               embedder::ScopedPlatformHandle platform_handle,
+                               platform::ScopedPlatformHandle platform_handle,
                                ProcessIdentifier slave_process_identifier,
                                util::AutoResetWaitableEvent* event);
   // Called by |Helper::OnError()|.
   void OnError(ProcessIdentifier process_identifier);
   // Posts a call to |master_process_delegate_->OnSlaveDisconnect()|.
   void CallOnSlaveDisconnect(embedder::SlaveInfo slave_info);
 
   // Asserts that the current thread is *not* |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()|).
@@ skipping 42 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_