Convert //remoting to use std::unique_ptr

remoting/host/clipboard_x11.cc

 // Copyright (c) 2012 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 "remoting/host/clipboard.h"
 
 #include <X11/Xlib.h>
+
+#include "base/memory/ptr_util.h"
 #undef Status  // Xlib.h #defines this, which breaks protobuf headers.
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "remoting/host/linux/x_server_clipboard.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 
 namespace remoting {
 
 // This code is expected to be called on the desktop thread only.
 class ClipboardX11 : public Clipboard,
                      public base::MessageLoopForIO::Watcher {
  public:
   ClipboardX11();
   ~ClipboardX11() override;
 
   // Clipboard interface.
-  void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
+  void Start(
+      std::unique_ptr<protocol::ClipboardStub> client_clipboard) override;
   void InjectClipboardEvent(const protocol::ClipboardEvent& event) override;
 
   // MessageLoopForIO::Watcher interface.
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
  private:
   void OnClipboardChanged(const std::string& mime_type,
                           const std::string& data);
   void PumpXEvents();
 
-  scoped_ptr<protocol::ClipboardStub> client_clipboard_;
+  std::unique_ptr<protocol::ClipboardStub> client_clipboard_;
 
   // Underlying X11 clipboard implementation.
   XServerClipboard x_server_clipboard_;
 
   // Connection to the X server, used by |x_server_clipboard_|. This is created
   // and owned by this class.
   Display* display_;
 
   // Watcher used to handle X11 events from |display_|.
   base::MessageLoopForIO::FileDescriptorWatcher x_connection_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(ClipboardX11);
 };
 
 ClipboardX11::ClipboardX11()
     : display_(nullptr) {
 }
 
 ClipboardX11::~ClipboardX11() {
   if (display_)
     XCloseDisplay(display_);
 }
 
 void ClipboardX11::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   // TODO(lambroslambrou): Share the X connection with InputInjector.
   display_ = XOpenDisplay(nullptr);
   if (!display_) {
     LOG(ERROR) << "Couldn't open X display";
     return;
   }
   client_clipboard_.swap(client_clipboard);
 
   x_server_clipboard_.Init(display_,
                            base::Bind(&ClipboardX11::OnClipboardChanged,
@@ skipping 34 matching lines @@
 void ClipboardX11::PumpXEvents() {
   DCHECK(display_);
 
   while (XPending(display_)) {
     XEvent event;
     XNextEvent(display_, &event);
     x_server_clipboard_.ProcessXEvent(&event);
   }
 }
 
-scoped_ptr<Clipboard> Clipboard::Create() {
-  return make_scoped_ptr(new ClipboardX11());
+std::unique_ptr<Clipboard> Clipboard::Create() {
+  return base::WrapUnique(new ClipboardX11());
 }
 
 }  // namespace remoting