Move us fully from gfx:: over to skia types for consistency.

remoting/host/client_session.cc

 // Copyright (c) 2011 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/client_session.h"
 
 #include <algorithm>
 
 #include "base/task.h"
 #include "remoting/host/capturer.h"
@@ skipping 76 matching lines @@
 
 void ClientSession::InjectMouseEvent(const MouseEvent& event) {
   if (authenticated_ && !ShouldIgnoreRemoteMouseInput(event)) {
     RecordMouseButtonState(event);
     MouseEvent event_to_inject = event;
     if (event.has_x() && event.has_y()) {
       // In case the client sends events with off-screen coordinates, modify
       // the event to lie within the current screen area.  This is better than
       // simply discarding the event, which might lose a button-up event at the
       // end of a drag'n'drop (or cause other related problems).
-      gfx::Point pos(event.x(), event.y());
-      const gfx::Size& screen = capturer_->size_most_recent();
-      pos.set_x(std::max(0, std::min(screen.width() - 1, pos.x())));
-      pos.set_y(std::max(0, std::min(screen.height() - 1, pos.y())));
+      SkIPoint pos(SkIPoint::Make(event.x(), event.y()));
+      const SkISize& screen = capturer_->size_most_recent();
+      pos.setX(std::max(0, std::min(screen.width() - 1, pos.x())));
+      pos.setY(std::max(0, std::min(screen.height() - 1, pos.y())));
       event_to_inject.set_x(pos.x());
       event_to_inject.set_y(pos.y());
 
       // Record the mouse position so we can use it if we need to inject
       // fake mouse button events. Note that we need to do this after we
       // clamp the values to the screen area.
       remote_mouse_pos_ = pos;
 
       injected_mouse_positions_.push_back(pos);
       if (injected_mouse_positions_.size() > kNumRemoteMousePositions) {
         VLOG(1) << "Injected mouse positions queue full.";
         injected_mouse_positions_.pop_front();
       }
     }
     input_stub_->InjectMouseEvent(event_to_inject);
   }
 }
 
 void ClientSession::OnDisconnected() {
   RestoreEventState();
   authenticated_ = false;
 }
 
-void ClientSession::LocalMouseMoved(const gfx::Point& mouse_pos) {
+void ClientSession::LocalMouseMoved(const SkIPoint& mouse_pos) {
   // If this is a genuine local input event (rather than an echo of a remote
   // input event that we've just injected), then ignore remote inputs for a
   // short time.
-  std::list<gfx::Point>::iterator found_position =
+  std::list<SkIPoint>::iterator found_position =
       std::find(injected_mouse_positions_.begin(),
                 injected_mouse_positions_.end(), mouse_pos);
   if (found_position != injected_mouse_positions_.end()) {
     // Remove it from the list, and any positions that were added before it,
     // if any.  This is because the local input monitor is assumed to receive
     // injected mouse position events in the order in which they were injected
     // (if at all).  If the position is found somewhere other than the front of
     // the queue, this would be because the earlier positions weren't
     // successfully injected (or the local input monitor might have skipped over
     // some positions), and not because the events were out-of-sequence.  These
@@ skipping 77 matching lines @@
       mouse.set_y(remote_mouse_pos_.y());
       mouse.set_button((MouseEvent::MouseButton)i);
       mouse.set_button_down(false);
       input_stub_->InjectMouseEvent(mouse);
     }
   }
   remote_mouse_button_state_ = 0;
 }
 
 }  // namespace remoting