Mojo: Move platform handle/channel stuff in system to embedder namespace.

mojo/system/raw_channel_posix.cc

 // 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.
 
 #include "mojo/system/raw_channel.h"
 
 #include <errno.h>
 #include <string.h>
 #include <unistd.h>
 
@@ skipping 17 matching lines @@
 namespace mojo {
 namespace system {
 
 namespace {
 
 const size_t kReadSize = 4096;
 
 class RawChannelPosix : public RawChannel,
                         public base::MessageLoopForIO::Watcher {
  public:
-  RawChannelPosix(ScopedPlatformHandle handle,
+  RawChannelPosix(embedder::ScopedPlatformHandle handle,
                   Delegate* delegate,
                   base::MessageLoop* message_loop);
   virtual ~RawChannelPosix();
 
   // |RawChannel| implementation:
   virtual bool Init() OVERRIDE;
   virtual void Shutdown() OVERRIDE;
   virtual bool WriteMessage(MessageInTransit* message) OVERRIDE;
 
  private:
@@ skipping 16 matching lines @@
 
   // Cancels all pending writes and destroys the contents of
   // |write_message_queue_|. Should only be called if |is_dead_| is false; sets
   // |is_dead_| to true. Must be called under |write_lock_|.
   void CancelPendingWritesNoLock();
 
   base::MessageLoopForIO* message_loop_for_io() {
     return static_cast<base::MessageLoopForIO*>(message_loop());
   }
 
-  ScopedPlatformHandle fd_;
+  embedder::ScopedPlatformHandle fd_;
 
   // Only used on the I/O thread:
   scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> read_watcher_;
   scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> write_watcher_;
 
   // We store data from |read()|s in |read_buffer_|. The start of |read_buffer_|
   // is always aligned with a message boundary (we will copy memory to ensure
   // this), but |read_buffer_| may be larger than the actual number of bytes we
   // have.
   std::vector<char> read_buffer_;
   size_t read_buffer_num_valid_bytes_;
 
   base::Lock write_lock_;  // Protects the following members.
   bool is_dead_;
   std::deque<MessageInTransit*> write_message_queue_;
   size_t write_message_offset_;
   // This is used for posting tasks from write threads to the I/O thread. It
   // must only be accessed under |write_lock_|. The weak pointers it produces
   // are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelPosix);
 };
 
-RawChannelPosix::RawChannelPosix(ScopedPlatformHandle handle,
+RawChannelPosix::RawChannelPosix(embedder::ScopedPlatformHandle handle,
                                  Delegate* delegate,
                                  base::MessageLoop* message_loop)
     : RawChannel(delegate, message_loop),
       fd_(handle.Pass()),
       read_buffer_num_valid_bytes_(0),
       is_dead_(false),
       write_message_offset_(0),
       weak_ptr_factory_(this) {
   CHECK_EQ(RawChannel::message_loop()->type(), base::MessageLoop::TYPE_IO);
   DCHECK(fd_.is_valid());
@@ skipping 282 matching lines @@
   }
   write_message_queue_.clear();
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
-RawChannel* RawChannel::Create(ScopedPlatformHandle handle,
+RawChannel* RawChannel::Create(embedder::ScopedPlatformHandle handle,
                                Delegate* delegate,
                                base::MessageLoop* message_loop) {
   return new RawChannelPosix(handle.Pass(), delegate, message_loop);
 }
 
 }  // namespace system
 }  // namespace mojo