Convert //remoting to use std::unique_ptr

remoting/host/input_injector_chromeos.cc

 // Copyright 2014 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/input_injector_chromeos.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "remoting/host/chromeos/point_transformer.h"
 #include "remoting/host/clipboard.h"
 #include "remoting/proto/internal.pb.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/ozone/public/input_controller.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/system_input_injector.h"
 
 namespace remoting {
@@ skipping 25 matching lines @@
 // This class is run exclusively on the UI thread of the browser process.
 class InputInjectorChromeos::Core {
  public:
   Core();
 
   // Mirrors the public InputInjectorChromeos interface.
   void InjectClipboardEvent(const ClipboardEvent& event);
   void InjectKeyEvent(const KeyEvent& event);
   void InjectTextEvent(const TextEvent& event);
   void InjectMouseEvent(const MouseEvent& event);
-  void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard);
+  void Start(std::unique_ptr<protocol::ClipboardStub> client_clipboard);
 
  private:
-  scoped_ptr<ui::SystemInputInjector> delegate_;
-  scoped_ptr<Clipboard> clipboard_;
+  std::unique_ptr<ui::SystemInputInjector> delegate_;
+  std::unique_ptr<Clipboard> clipboard_;
 
   // Used to rotate the input coordinates appropriately based on the current
   // display rotation settings.
-  scoped_ptr<PointTransformer> point_transformer_;
+  std::unique_ptr<PointTransformer> point_transformer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 InputInjectorChromeos::Core::Core() {
 }
 
 void InputInjectorChromeos::Core::InjectClipboardEvent(
     const ClipboardEvent& event) {
   clipboard_->InjectClipboardEvent(event);
@@ skipping 26 matching lines @@
   } else if (event.has_wheel_delta_y() || event.has_wheel_delta_x()) {
     delegate_->InjectMouseWheel(event.wheel_delta_x(), event.wheel_delta_y());
   } else {
     DCHECK(event.has_x() && event.has_y());
     delegate_->MoveCursorTo(point_transformer_->ToScreenCoordinates(
         gfx::PointF(event.x(), event.y())));
   }
 }
 
 void InputInjectorChromeos::Core::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   ui::OzonePlatform* ozone_platform = ui::OzonePlatform::GetInstance();
   delegate_ = ozone_platform->CreateSystemInputInjector();
   DCHECK(delegate_);
 
   // Implemented by remoting::ClipboardAura.
   clipboard_ = Clipboard::Create();
   clipboard_->Start(std::move(client_clipboard));
   point_transformer_.reset(new PointTransformer());
 }
 
@@ skipping 29 matching lines @@
   input_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::InjectMouseEvent,
                             base::Unretained(core_.get()), event));
 }
 
 void InputInjectorChromeos::InjectTouchEvent(const TouchEvent& event) {
   NOTIMPLEMENTED() << "Raw touch event injection not implemented for ChromeOS.";
 }
 
 void InputInjectorChromeos::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   input_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::Start, base::Unretained(core_.get()),
                             base::Passed(&client_clipboard)));
 }
 
 // static
-scoped_ptr<InputInjector> InputInjector::Create(
+std::unique_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   // The Ozone input injector must be called on the UI task runner of the
   // browser process.
-  return make_scoped_ptr(new InputInjectorChromeos(ui_task_runner));
+  return base::WrapUnique(new InputInjectorChromeos(ui_task_runner));
 }
 
 // static
 bool InputInjector::SupportsTouchEvents() {
   return false;
 }
 
 }  // namespace remoting