Remove dependency on skia from remoting

remoting/host/local_input_monitor_mac.mm

 // 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/local_input_monitor.h"
 
 #import <AppKit/AppKit.h>
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "remoting/host/client_session_control.h"
-#include "third_party/skia/include/core/SkPoint.h"
 #import "third_party/GTM/AppKit/GTMCarbonEvent.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 // Esc Key Code is 53.
 // http://boredzo.org/blog/wp-content/uploads/2007/05/IMTx-virtual-keycodes.pdf
 static const NSUInteger kEscKeyCode = 53;
 
 namespace remoting {
 namespace {
 
 class LocalInputMonitorMac : public base::NonThreadSafe,
                              public LocalInputMonitor {
  public:
   // Invoked by LocalInputMonitorManager.
   class EventHandler {
    public:
     virtual ~EventHandler() {}
 
-    virtual void OnLocalMouseMoved(const SkIPoint& position) = 0;
+    virtual void OnLocalMouseMoved(const webrtc::DesktopVector& position) = 0;
     virtual void OnDisconnectShortcut() = 0;
   };
 
   LocalInputMonitorMac(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control);
   virtual ~LocalInputMonitorMac();
 
  private:
@@ skipping 14 matching lines @@
   base::ScopedCFTypeRef<CFMachPortRef> mouseMachPort_;
   remoting::LocalInputMonitorMac::EventHandler* monitor_;
 }
 
 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor;
 
 // Called when the hotKey is hit.
 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey;
 
 // Called when the local mouse moves
-- (void)localMouseMoved:(const SkIPoint&)mousePos;
+- (void)localMouseMoved:(const webrtc::DesktopVector&)mousePos;
 
 // Must be called when the LocalInputMonitorManager is no longer to be used.
 // Similar to NSTimer in that more than a simple release is required.
 - (void)invalidate;
 
 @end
 
 static CGEventRef LocalMouseMoved(CGEventTapProxy proxy, CGEventType type,
                                   CGEventRef event, void* context) {
   int64_t pid = CGEventGetIntegerValueField(event, kCGEventSourceUnixProcessID);
   if (pid == 0) {
     CGPoint cgMousePos = CGEventGetLocation(event);
-    SkIPoint mousePos = SkIPoint::Make(cgMousePos.x, cgMousePos.y);
+    webrtc::DesktopVector mousePos(cgMousePos.x, cgMousePos.y);
     [static_cast<LocalInputMonitorManager*>(context) localMouseMoved:mousePos];
   }
   return NULL;
 }
 
 @implementation LocalInputMonitorManager
 
 - (id)initWithMonitor:(remoting::LocalInputMonitorMac::EventHandler*)monitor {
   if ((self = [super init])) {
     monitor_ = monitor;
@@ skipping 25 matching lines @@
       return nil;
     }
   }
   return self;
 }
 
 - (void)hotKeyHit:(GTMCarbonHotKey*)hotKey {
   monitor_->OnDisconnectShortcut();
 }
 
-- (void)localMouseMoved:(const SkIPoint&)mousePos {
+- (void)localMouseMoved:(const webrtc::DesktopVector&)mousePos {
   monitor_->OnLocalMouseMoved(mousePos);
 }
 
 - (void)invalidate {
   if (hotKey_) {
     GTMCarbonEventDispatcherHandler* handler =
         [GTMCarbonEventDispatcherHandler sharedEventDispatcherHandler];
     [handler unregisterHotKey:hotKey_];
     hotKey_ = NULL;
   }
@@ skipping 24 matching lines @@
   void Stop();
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
 
   void StartOnUiThread();
   void StopOnUiThread();
 
   // EventHandler interface.
-  virtual void OnLocalMouseMoved(const SkIPoint& position) OVERRIDE;
+  virtual void OnLocalMouseMoved(
+      const webrtc::DesktopVector& position) OVERRIDE;
   virtual void OnDisconnectShortcut() OVERRIDE;
 
   // Task runner on which public methods of this class must be called.
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
   // Task runner on which |window_| is created.
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   LocalInputMonitorManager* manager_;
 
@@ skipping 53 matching lines @@
 }
 
 void LocalInputMonitorMac::Core::StopOnUiThread() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   [manager_ invalidate];
   [manager_ release];
   manager_ = nil;
 }
 
-void LocalInputMonitorMac::Core::OnLocalMouseMoved(const SkIPoint& position) {
+void LocalInputMonitorMac::Core::OnLocalMouseMoved(
+    const webrtc::DesktopVector& position) {
   caller_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
                             client_session_control_,
                             position));
 }
 
 void LocalInputMonitorMac::Core::OnDisconnectShortcut() {
   caller_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
                             client_session_control_));
 }
 
 }  // namespace
 
 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
   return scoped_ptr<LocalInputMonitor>(
       new LocalInputMonitorMac(caller_task_runner,
                                ui_task_runner,
                                client_session_control));
 }
 
 }  // namespace remoting