Convert //remoting to use std::unique_ptr

remoting/host/input_injector_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/input_injector.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XTest.h>
@@ skipping 111 matching lines @@
   // Clipboard stub interface.
   void InjectClipboardEvent(const ClipboardEvent& event) override;
 
   // InputStub interface.
   void InjectKeyEvent(const KeyEvent& event) override;
   void InjectTextEvent(const TextEvent& event) override;
   void InjectMouseEvent(const MouseEvent& event) override;
   void InjectTouchEvent(const TouchEvent& event) override;
 
   // InputInjector interface.
-  void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
+  void Start(
+      std::unique_ptr<protocol::ClipboardStub> client_clipboard) override;
 
  private:
   // The actual implementation resides in InputInjectorX11::Core class.
   class Core : public base::RefCountedThreadSafe<Core> {
    public:
     explicit Core(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
     bool Init();
 
     // Mirrors the ClipboardStub interface.
     void InjectClipboardEvent(const ClipboardEvent& event);
 
     // Mirrors the InputStub interface.
     void InjectKeyEvent(const KeyEvent& event);
     void InjectTextEvent(const TextEvent& event);
     void InjectMouseEvent(const MouseEvent& event);
 
     // Mirrors the InputInjector interface.
-    void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard);
+    void Start(std::unique_ptr<protocol::ClipboardStub> client_clipboard);
 
     void Stop();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void InitClipboard();
 
     // Queries whether keyboard auto-repeat is globally enabled. This is used
@@ skipping 27 matching lines @@
     // Number of buttons we support.
     // Left, Right, Middle, VScroll Up/Down, HScroll Left/Right.
     static const int kNumPointerButtons = 7;
 
     int pointer_button_map_[kNumPointerButtons];
 
 #if defined(OS_CHROMEOS)
     PointTransformer point_transformer_;
 #endif
 
-    scoped_ptr<Clipboard> clipboard_;
+    std::unique_ptr<Clipboard> clipboard_;
 
     bool saved_auto_repeat_enabled_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(InputInjectorX11);
 };
@@ skipping 25 matching lines @@
 
 void InputInjectorX11::InjectMouseEvent(const MouseEvent& event) {
   core_->InjectMouseEvent(event);
 }
 
 void InputInjectorX11::InjectTouchEvent(const TouchEvent& event) {
   NOTIMPLEMENTED() << "Raw touch event injection not implemented for X11.";
 }
 
 void InputInjectorX11::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(std::move(client_clipboard));
 }
 
 InputInjectorX11::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       latest_mouse_position_(-1, -1),
       wheel_ticks_x_(0.0f),
       wheel_ticks_y_(0.0f),
       display_(XOpenDisplay(nullptr)),
@@ skipping 259 matching lines @@
 }
 
 void InputInjectorX11::Core::InitMouseButtonMap() {
   // TODO(rmsousa): Run this on global/device mapping change events.
 
   // Do not touch global pointer mapping, since this may affect the local user.
   // Instead, try to work around it by reversing the mapping.
   // Note that if a user has a global mapping that completely disables a button
   // (by assigning 0 to it), we won't be able to inject it.
   int num_buttons = XGetPointerMapping(display_, nullptr, 0);
-  scoped_ptr<unsigned char[]> pointer_mapping(new unsigned char[num_buttons]);
+  std::unique_ptr<unsigned char[]> pointer_mapping(
+      new unsigned char[num_buttons]);
   num_buttons = XGetPointerMapping(display_, pointer_mapping.get(),
                                    num_buttons);
   for (int i = 0; i < kNumPointerButtons; i++) {
     pointer_button_map_[i] = -1;
   }
   for (int i = 0; i < num_buttons; i++) {
     // Reverse the mapping.
     if (pointer_mapping[i] > 0 && pointer_mapping[i] <= kNumPointerButtons)
       pointer_button_map_[pointer_mapping[i] - 1] = i + 1;
   }
@@ skipping 36 matching lines @@
   }
 
   XDevice* device = XOpenDevice(display_, device_id);
   if (!device) {
     LOG(ERROR) << "Cannot open XTest device.";
     return;
   }
 
   int num_device_buttons =
       XGetDeviceButtonMapping(display_, device, nullptr, 0);
-  scoped_ptr<unsigned char[]> button_mapping(new unsigned char[num_buttons]);
+  std::unique_ptr<unsigned char[]> button_mapping(
+      new unsigned char[num_buttons]);
   for (int i = 0; i < num_device_buttons; i++) {
     button_mapping[i] = i + 1;
   }
   error = XSetDeviceButtonMapping(display_, device, button_mapping.get(),
                                   num_device_buttons);
   if (error != Success)
     LOG(ERROR) << "Failed to set XTest device button mapping: " << error;
 
   XCloseDevice(display_, device);
 }
@@ skipping 20 matching lines @@
   return (dx > 0 ? pointer_button_map_[5] : pointer_button_map_[6]);
 }
 
 int InputInjectorX11::Core::VerticalScrollWheelToX11ButtonNumber(int dy) {
   // Positive y-values are wheel scroll-up events (button 4), negative y-values
   // are wheel scroll-down events (button 5).
   return (dy > 0 ? pointer_button_map_[3] : pointer_button_map_[4]);
 }
 
 void InputInjectorX11::Core::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+    std::unique_ptr<protocol::ClipboardStub> client_clipboard) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Core::Start, this, base::Passed(&client_clipboard)));
     return;
   }
 
   InitMouseButtonMap();
 
   clipboard_->Start(std::move(client_clipboard));
 }
 
 void InputInjectorX11::Core::Stop() {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(&Core::Stop, this));
     return;
   }
 
   clipboard_.reset();
 }
 
 }  // namespace
 
 // static
-scoped_ptr<InputInjector> InputInjector::Create(
+std::unique_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  scoped_ptr<InputInjectorX11> injector(
+  std::unique_ptr<InputInjectorX11> injector(
       new InputInjectorX11(main_task_runner));
   if (!injector->Init())
     return nullptr;
   return std::move(injector);
 }
 
 // static
 bool InputInjector::SupportsTouchEvents() {
   return false;
 }
 
 }  // namespace remoting