Some easy conversions of scoped_ptr -> std::unique_ptr in the EDK.

mojo/edk/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/edk/system/raw_channel.h"
 
 #include <errno.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <deque>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
@@ skipping 25 matching lines @@
       const MessageInTransit::View& message_view) override;
   IOResult Read(size_t* bytes_read) override;
   IOResult ScheduleRead() override;
   embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
       size_t num_platform_handles,
       const void* platform_handle_table) override;
   IOResult WriteNoLock(size_t* platform_handles_written,
                        size_t* bytes_written) override;
   IOResult ScheduleWriteNoLock() override;
   void OnInit() override;
-  void OnShutdownNoLock(scoped_ptr<ReadBuffer> read_buffer,
-                        scoped_ptr<WriteBuffer> write_buffer) override;
+  void OnShutdownNoLock(std::unique_ptr<ReadBuffer> read_buffer,
+                        std::unique_ptr<WriteBuffer> write_buffer) override;
 
   // |base::MessageLoopForIO::Watcher| implementation:
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
   // Implements most of |Read()| (except for a bit of clean-up):
   IOResult ReadImpl(size_t* bytes_read);
 
   // Watches for |fd_| to become writable. Must be called on the I/O thread.
   void WaitToWrite();
 
   embedder::ScopedPlatformHandle fd_;
 
   // The following members are only used on the I/O thread:
-  scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> read_watcher_;
-  scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> write_watcher_;
+  std::unique_ptr<base::MessageLoopForIO::FileDescriptorWatcher> read_watcher_;
+  std::unique_ptr<base::MessageLoopForIO::FileDescriptorWatcher> write_watcher_;
 
   bool pending_read_;
 
   std::deque<embedder::PlatformHandle> read_platform_handles_;
 
   bool pending_write_ MOJO_GUARDED_BY(write_mutex());
 
   // This is used for posting tasks from write threads to the I/O thread. The
   // weak pointers it produces are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_
@@ skipping 234 matching lines @@
 
   // I don't know how this can fail (unless |fd_| is bad, in which case it's a
   // bug in our code). I also don't know if |WatchFileDescriptor()| actually
   // fails cleanly.
   CHECK(message_loop_for_io()->WatchFileDescriptor(
       fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ,
       read_watcher_.get(), this));
 }
 
 void RawChannelPosix::OnShutdownNoLock(
-    scoped_ptr<ReadBuffer> /*read_buffer*/,
-    scoped_ptr<WriteBuffer> /*write_buffer*/) {
+    std::unique_ptr<ReadBuffer> /*read_buffer*/,
+    std::unique_ptr<WriteBuffer> /*write_buffer*/) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
   write_mutex().AssertHeld();
 
   read_watcher_.reset();   // This will stop watching (if necessary).
   write_watcher_.reset();  // This will stop watching (if necessary).
 
   pending_read_ = false;
   pending_write_ = false;
 
   DCHECK(fd_.is_valid());
@@ skipping 126 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelPosix(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo