Remove dependency on skia from remoting

remoting/host/input_injector_linux.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 <X11/extensions/XInput.h>
 #include <X11/extensions/XTest.h>
 #include <X11/Xlib.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/clipboard.h"
 #include "remoting/proto/internal.pb.h"
-#include "third_party/skia/include/core/SkPoint.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 
 namespace remoting {
 
 namespace {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 
@@ skipping 60 matching lines @@
     // Compensates for global button mappings and resets the XTest device
     // mapping.
     void InitMouseButtonMap();
     int MouseButtonToX11ButtonNumber(MouseEvent::MouseButton button);
     int HorizontalScrollWheelToX11ButtonNumber(int dx);
     int VerticalScrollWheelToX11ButtonNumber(int dy);
 
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
     std::set<int> pressed_keys_;
-    SkIPoint latest_mouse_position_;
+    webrtc::DesktopVector latest_mouse_position_;
     float wheel_ticks_x_;
     float wheel_ticks_y_;
 
     // X11 graphics context.
     Display* display_;
     Window root_window_;
 
     int test_event_base_;
     int test_error_base_;
 
@@ skipping 40 matching lines @@
 }
 
 void InputInjectorLinux::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(client_clipboard.Pass());
 }
 
 InputInjectorLinux::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
-      latest_mouse_position_(SkIPoint::Make(-1, -1)),
+      latest_mouse_position_(-1, -1),
       wheel_ticks_x_(0.0f),
       wheel_ticks_y_(0.0f),
       display_(XOpenDisplay(NULL)),
       root_window_(BadValue),
       saved_auto_repeat_enabled_(false) {
 }
 
 bool InputInjectorLinux::Core::Init() {
   CHECK(display_);
 
@@ skipping 118 matching lines @@
 void InputInjectorLinux::Core::InjectMouseEvent(const MouseEvent& event) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&Core::InjectMouseEvent, this, event));
     return;
   }
 
   if (event.has_delta_x() &&
       event.has_delta_y() &&
       (event.delta_x() != 0 || event.delta_y() != 0)) {
-    latest_mouse_position_ = SkIPoint::Make(-1, -1);
+    latest_mouse_position_.set(-1, -1);
     VLOG(3) << "Moving mouse by " << event.delta_x() << "," << event.delta_y();
     XTestFakeRelativeMotionEvent(display_,
                                  event.delta_x(), event.delta_y(),
                                  CurrentTime);
 
   } else if (event.has_x() && event.has_y()) {
     // Injecting a motion event immediately before a button release results in
     // a MotionNotify even if the mouse position hasn't changed, which confuses
     // apps which assume MotionNotify implies movement. See crbug.com/138075.
     bool inject_motion = true;
-    SkIPoint new_mouse_position(SkIPoint::Make(event.x(), event.y()));
+    webrtc::DesktopVector new_mouse_position(
+        webrtc::DesktopVector(event.x(), event.y()));
     if (event.has_button() && event.has_button_down() && !event.button_down()) {
-      if (new_mouse_position == latest_mouse_position_)
+      if (new_mouse_position.equals(latest_mouse_position_))
         inject_motion = false;
     }
 
     if (inject_motion) {
-      latest_mouse_position_ =
-          SkIPoint::Make(std::max(0, new_mouse_position.x()),
-                         std::max(0, new_mouse_position.y()));
+      latest_mouse_position_.set(std::max(0, new_mouse_position.x()),
+                                 std::max(0, new_mouse_position.y()));
 
       VLOG(3) << "Moving mouse to " << latest_mouse_position_.x()
               << "," << latest_mouse_position_.y();
       XTestFakeMotionEvent(display_, DefaultScreen(display_),
                            latest_mouse_position_.x(),
                            latest_mouse_position_.y(),
                            CurrentTime);
     }
   }
 
@@ skipping 180 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   scoped_ptr<InputInjectorLinux> injector(
       new InputInjectorLinux(main_task_runner));
   if (!injector->Init())
     return scoped_ptr<InputInjector>();
   return injector.PassAs<InputInjector>();
 }
 
 }  // namespace remoting