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

mojo/edk/system/raw_channel.h

 // Copyright 2013 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_RAW_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_RAW_CHANNEL_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
-#include "mojo/edk/embedder/scoped_platform_handle.h"
+#include "mojo/edk/platform/platform_handle.h"
+#include "mojo/edk/platform/scoped_platform_handle.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace base {
 class MessageLoopForIO;
 }
 
@@ skipping 36 matching lines @@
       // Unknown read error.
       ERROR_READ_UNKNOWN,
       // Generic write error.
       ERROR_WRITE
     };
 
     // Called when a message is read. This may call the |RawChannel|'s
     // |Shutdown()| and then (if desired) destroy it.
     virtual void OnReadMessage(
         const MessageInTransit::View& message_view,
-        std::unique_ptr<std::vector<embedder::ScopedPlatformHandle>>
+        std::unique_ptr<std::vector<platform::ScopedPlatformHandle>>
             platform_handles) = 0;
 
     // Called when there's a (fatal) error. This may call the |RawChannel|'s
     // |Shutdown()| and then (if desired) destroy it.
     //
     // For each raw channel, there'll be at most one |ERROR_READ_...| and at
     // most one |ERROR_WRITE| notification. After |OnError(ERROR_READ_...)|,
     // |OnReadMessage()| won't be called again.
     virtual void OnError(Error error) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
   // Static factory method. |handle| should be a handle to a
   // (platform-appropriate) bidirectional communication channel (e.g., a socket
   // on POSIX, a named pipe on Windows).
   static std::unique_ptr<RawChannel> Create(
-      embedder::ScopedPlatformHandle handle);
+      platform::ScopedPlatformHandle handle);
 
   // This must be called (on an I/O thread) before this object is used. Does
   // *not* take ownership of |delegate|. Both the I/O thread and |delegate| must
   // remain alive until |Shutdown()| is called (unless this fails); |delegate|
   // will no longer be used after |Shutdown()|.
   void Init(Delegate* delegate) MOJO_NOT_THREAD_SAFE;
 
   // This must be called (on the I/O thread) before this object is destroyed.
   void Shutdown() MOJO_NOT_THREAD_SAFE;
 
@@ skipping 65 matching lines @@
     // true. There are two components to this: the actual |PlatformHandle|s
     // (which should be closed once sent) and any additional serialization
     // information (which will be embedded in the message's data; there are
     // |GetSerializedPlatformHandleSize()| bytes per handle). Once all platform
     // handles have been sent, the message data should be written next (see
     // |GetBuffers()|).
     // TODO(vtl): Maybe this method should be const, but
     // |PlatformHandle::CloseIfNecessary()| isn't const (and actually modifies
     // state).
     void GetPlatformHandlesToSend(size_t* num_platform_handles,
-                                  embedder::PlatformHandle** platform_handles,
+                                  platform::PlatformHandle** platform_handles,
                                   void** serialization_data);
 
     // Gets buffers to be written. These buffers will always come from the front
     // of |message_queue_|. Once they are completely written, the front
     // |MessageInTransit| should be popped (and destroyed); this is done in
     // |OnWriteCompletedNoLock()|.
     void GetBuffers(std::vector<Buffer>* buffers) const;
 
    private:
     friend class RawChannel;
@@ skipping 69 matching lines @@
   // Similar to |Read()|, except that the implementing subclass must also
   // guarantee that the method doesn't succeed synchronously, i.e., it only
   // returns |IO_FAILED_...| or |IO_PENDING|.
   virtual IOResult ScheduleRead() MOJO_LOCKS_EXCLUDED(write_mutex_) = 0;
 
   // Called by |OnReadCompleted()| to get the platform handles associated with
   // the given platform handle table (from a message). This should only be
   // called when |num_platform_handles| is nonzero. Returns null if the
   // |num_platform_handles| handles are not available. Only called on the I/O
   // thread.
-  virtual std::unique_ptr<std::vector<embedder::ScopedPlatformHandle>>
+  virtual std::unique_ptr<std::vector<platform::ScopedPlatformHandle>>
   GetReadPlatformHandles(size_t num_platform_handles,
                          const void* platform_handle_table)
       MOJO_LOCKS_EXCLUDED(write_mutex_) = 0;
 
   // Writes contents in |write_buffer_no_lock()|.
   // This class guarantees that:
   // - the |PlatformHandle|s given by |GetPlatformHandlesToSend()| and the
   //   buffer(s) given by |GetBuffers()| will remain valid until write
   //   completion (see also the comments for |OnShutdownNoLock()|);
   // - a second write is not started if there is a pending write.
@@ skipping 56 matching lines @@
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_
       MOJO_GUARDED_BY(write_mutex_);
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_RAW_CHANNEL_H_