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

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/scoped_platform_handle.h"
 #include "mojo/edk/embedder/slave_process_delegate.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/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 22 matching lines @@
   // 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<platform::TaskRunner>&& delegate_thread_task_runner,
             embedder::SlaveProcessDelegate* slave_process_delegate,
-            embedder::ScopedPlatformHandle platform_handle);
+            platform::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;
+                 platform::ScopedPlatformHandle* platform_handle) override;
 
  private:
   // These should only be called on |private_thread_|:
-  void InitOnPrivateThread(embedder::ScopedPlatformHandle platform_handle);
+  void InitOnPrivateThread(platform::ScopedPlatformHandle platform_handle);
   void ShutdownOnPrivateThread();
   void AllowConnectOnPrivateThread(const ConnectionIdentifier& connection_id,
                                    Result* result);
   void CancelConnectOnPrivateThread(const ConnectionIdentifier& connection_id,
                                     Result* result);
   void ConnectOnPrivateThread(const ConnectionIdentifier& connection_id,
                               Result* result,
                               ProcessIdentifier* peer_process_identifier,
                               bool* is_first,
-                              embedder::ScopedPlatformHandle* platform_handle);
+                              platform::ScopedPlatformHandle* platform_handle);
 
   // |RawChannel::Delegate| methods (only called on |private_thread_|):
   void OnReadMessage(
       const MessageInTransit::View& message_view,
-      std::unique_ptr<std::vector<embedder::ScopedPlatformHandle>>
+      std::unique_ptr<std::vector<platform::ScopedPlatformHandle>>
           platform_handles) override;
   void OnError(Error error) override;
 
   // 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()|).
   void AssertNotOnPrivateThread() const;
 
   // 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
@@ skipping 18 matching lines @@
     NOT_AWAITING_ACK,
     AWAITING_ACCEPT_CONNECT_ACK,
     AWAITING_CANCEL_CONNECT_ACK,
     AWAITING_CONNECT_ACK
   };
   AwaitingAckType awaiting_ack_type_;
   Result* ack_result_;
   // Used only when waiting for the ack to "connect":
   ProcessIdentifier* ack_peer_process_identifier_;
   bool* ack_is_first_;
-  embedder::ScopedPlatformHandle* ack_platform_handle_;
+  platform::ScopedPlatformHandle* ack_platform_handle_;
 
   // The (synchronous) |ConnectionManager| methods are implemented in the
   // following way (T is any thread other than |private_thread_|):
   //
   // On thread T:
   //  1. |F()| is called, where F is one of the |ConnectionManager| methods.
   //  2. |lock_| is acquired.
   //  3. |FImpl()| is posted to |private_thread_|.
   //  4. |event_| is waited on (while holding |lock_|!).
   //
@@ skipping 17 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_