Fix breaking change in It2me Host on Ozone

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 28 matching lines @@
       NOTREACHED();
       return ui::EF_NONE;
   }
 }
 
 }  // namespace
 
 // This class is run exclusively on the UI thread of the browser process.
 class InputInjectorChromeos::Core {
  public:
-  Core(scoped_ptr<ui::SystemInputInjector> delegate_,
-       ui::InputController* input_controller);
+  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);
 
  private:
   void HandleAutoRepeat(ui::DomCode dom_code, bool pressed);
 
   scoped_ptr<ui::SystemInputInjector> delegate_;
   ui::InputController* input_controller_;
   scoped_ptr<Clipboard> clipboard_;
 
   // Used to rotate the input coordinates appropriately based on the current
   // display rotation settings.
   scoped_ptr<PointTransformer> point_transformer_;
 
   // Used by HandleAutoRepeat().
   std::set<ui::DomCode> pressed_keys_;
   bool saved_auto_repeat_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-InputInjectorChromeos::Core::Core(scoped_ptr<ui::SystemInputInjector> delegate,
-                                  ui::InputController* input_controller)
-    : delegate_(delegate.Pass()),
-      input_controller_(input_controller),
-      saved_auto_repeat_enabled_(false) {
-  DCHECK(delegate_);
-  DCHECK(input_controller_);
+InputInjectorChromeos::Core::Core() : saved_auto_repeat_enabled_(false) {
 }
 
 void InputInjectorChromeos::Core::InjectClipboardEvent(
     const ClipboardEvent& event) {
   clipboard_->InjectClipboardEvent(event);
 }
 
 void InputInjectorChromeos::Core::InjectKeyEvent(const KeyEvent& event) {
   DCHECK(event.has_pressed());
   DCHECK(event.has_usb_keycode());
@@ skipping 55 matching lines @@
     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) {
+  ui::OzonePlatform* ozone_platform = ui::OzonePlatform::GetInstance();
+  delegate_ = ozone_platform->CreateSystemInputInjector();
+  DCHECK(delegate_);
+  input_controller_ = ozone_platform->GetInputController();
+  DCHECK(input_controller_);
+
+  // Implemented by remoting::ClipboardAura.
   clipboard_ = Clipboard::Create();
   clipboard_->Start(client_clipboard.Pass());
   point_transformer_.reset(new PointTransformer());
 }
 
 InputInjectorChromeos::InputInjectorChromeos(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : input_task_runner_(task_runner) {
-  ui::OzonePlatform* ozone_platform = ui::OzonePlatform::GetInstance();
-  core_.reset(new Core(ozone_platform->CreateSystemInputInjector(),
-                       ozone_platform->GetInputController()));
+  core_.reset(new Core());
 }
 
 InputInjectorChromeos::~InputInjectorChromeos() {
   input_task_runner_->DeleteSoon(FROM_HERE, core_.release());
 }
 
 void InputInjectorChromeos::InjectClipboardEvent(const ClipboardEvent& event) {
   input_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::InjectClipboardEvent,
                             base::Unretained(core_.get()), event));
@@ skipping 27 matching lines @@
 // static
 scoped_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));
 }
 
 }  // namespace remoting