Remove dependency on skia from remoting

remoting/host/host_window_proxy.cc

 // Copyright 2013 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/host_window_proxy.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/host/client_session_control.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
 
 // Runs an instance of |HostWindow| on the |ui_task_runner_| thread.
 class HostWindowProxy::Core
     : public base::RefCountedThreadSafe<Core>,
       public ClientSessionControl {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
        scoped_ptr<HostWindow> host_window);
 
   // Starts |host_window_| on the |ui_task_runner_| thread.
   void Start(const base::WeakPtr<ClientSessionControl>& client_session_control);
 
   // Destroys |host_window_| on the |ui_task_runner_| thread.
   void Stop();
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
 
   // Start() and Stop() equivalents called on the |ui_task_runner_| thread.
   void StartOnUiThread(const std::string& client_jid);
   void StopOnUiThread();
 
   // ClientSessionControl interface.
   virtual const std::string& client_jid() const OVERRIDE;
   virtual void DisconnectSession() OVERRIDE;
-  virtual void OnLocalMouseMoved(const SkIPoint& position) OVERRIDE;
+  virtual void OnLocalMouseMoved(
+      const webrtc::DesktopVector& position) OVERRIDE;
   virtual void SetDisableInputs(bool disable_inputs) OVERRIDE;
 
   // Task runner on which public methods of this class must be called.
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
   // Task runner on which |host_window_| is running.
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   // Stores the client's JID so it can be read on the |ui_task_runner_| thread.
   std::string client_jid_;
@@ skipping 93 matching lines @@
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(FROM_HERE,
                                   base::Bind(&Core::DisconnectSession, this));
     return;
   }
 
   if (client_session_control_.get())
     client_session_control_->DisconnectSession();
 }
 
-void HostWindowProxy::Core::OnLocalMouseMoved(const SkIPoint& position) {
+void HostWindowProxy::Core::OnLocalMouseMoved(
+    const webrtc::DesktopVector& position) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::OnLocalMouseMoved, this, position));
     return;
   }
 
   if (client_session_control_.get())
     client_session_control_->OnLocalMouseMoved(position);
 }
 
 void HostWindowProxy::Core::SetDisableInputs(bool disable_inputs) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::SetDisableInputs, this, disable_inputs));
     return;
   }
 
   if (client_session_control_.get())
     client_session_control_->SetDisableInputs(disable_inputs);
 }
 
 }  // namespace remoting