EDK: Convert remaining scoped_ptr -> std::unique_ptr in //mojo/edk/system.

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/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_in_transit_queue.h"
 #include "mojo/edk/system/mutex.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/edk/system/thread_annotations.h"
 #include "mojo/public/cpp/system/macros.h"
 
@@ skipping 73 matching lines @@
   // 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;
 
   // Writes the given message (or schedules it to be written). |message| must
   // have no |Dispatcher|s still attached (i.e.,
   // |SerializeAndCloseDispatchers()| should have been called). This method is
   // thread-safe and may be called from any thread. Returns true on success.
-  bool WriteMessage(scoped_ptr<MessageInTransit> message);
+  bool WriteMessage(std::unique_ptr<MessageInTransit> message);
 
   // Returns true if the write buffer is empty (i.e., all messages written using
   // |WriteMessage()| have actually been sent.
   // TODO(vtl): We should really also notify our delegate when the write buffer
   // becomes empty (or something like that).
   bool IsWriteBufferEmpty();
 
   // Returns the amount of space needed in the |MessageInTransit|'s
   // |TransportData|'s "platform handle table" per platform handle (to be
   // attached to a message). (This amount may be zero.)
@@ skipping 103 matching lines @@
   ReadBuffer* read_buffer() { return read_buffer_.get(); }
 
   WriteBuffer* write_buffer_no_lock()
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(write_mutex_) {
     return write_buffer_.get();
   }
 
   // Adds |message| to the write message queue. Implementation subclasses may
   // override this to add any additional "control" messages needed. This is
   // called (on any thread).
-  virtual void EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message)
+  virtual void EnqueueMessageNoLock(std::unique_ptr<MessageInTransit> message)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(write_mutex_);
 
   // Handles any control messages targeted to the |RawChannel| (or
   // implementation subclass). Implementation subclasses may override this to
   // handle any implementation-specific control messages, but should call
   // |RawChannel::OnReadMessageForRawChannel()| for any remaining messages.
   // Returns true on success and false on error (e.g., invalid control message).
   // This is only called on the I/O thread.
   virtual bool OnReadMessageForRawChannel(
       const MessageInTransit::View& message_view);
@@ skipping 90 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_