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

remoting/host/client_session_unittest.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 "remoting/host/host_mock_objects.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
@@ skipping 27 matching lines @@
   virtual void SetUp() {
     client_jid_ = "user@domain/rest-of-jid";
     EXPECT_CALL(session_, jid()).WillRepeatedly(ReturnRef(client_jid_));
 
     connection_ = new MockConnectionToClient(
         &connection_event_handler_, &host_stub_, &input_stub_);
 
     EXPECT_CALL(*connection_, session()).WillRepeatedly(Return(&session_));
 
     // Set up a large default screen size that won't affect most tests.
-    default_screen_size_.SetSize(1000, 1000);
+    default_screen_size_.set(1000, 1000);
     ON_CALL(capturer_, size_most_recent()).WillByDefault(ReturnRef(
         default_screen_size_));
 
     user_authenticator_ = new MockUserAuthenticator();
     client_session_ = new ClientSession(
         &session_event_handler_,
         user_authenticator_,
         connection_,
         &input_stub_,
         &capturer_);
   }
 
  protected:
-  gfx::Size default_screen_size_;
+  SkISize default_screen_size_;
   MessageLoop message_loop_;
   std::string client_jid_;
   MockSession session_;
   MockConnectionToClientEventHandler connection_event_handler_;
   MockHostStub host_stub_;
   MockInputStub input_stub_;
   MockCapturer capturer_;
   MockClientSessionEventHandler session_event_handler_;
   MockUserAuthenticator* user_authenticator_;
   scoped_refptr<MockConnectionToClient> connection_;
@@ skipping 90 matching lines @@
   EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
       .WillOnce(Return(true));
   EXPECT_CALL(session_event_handler_, LocalLoginSucceeded(_));
   EXPECT_CALL(input_stub_, InjectMouseEvent(EqualsMouseEvent(100, 101)));
   EXPECT_CALL(input_stub_, InjectMouseEvent(EqualsMouseEvent(200, 201)));
 
   client_session_->BeginSessionRequest(&credentials, new DummyTask());
   // This event should get through to the input stub.
   client_session_->InjectMouseEvent(mouse_event1);
   // This one should too because the local event echoes the remote one.
-  client_session_->LocalMouseMoved(gfx::Point(mouse_event1.x(),
-                                              mouse_event1.y()));
+  client_session_->LocalMouseMoved(SkIPoint::Make(mouse_event1.x(),
+                                                  mouse_event1.y()));
   client_session_->InjectMouseEvent(mouse_event2);
   // This one should not.
-  client_session_->LocalMouseMoved(gfx::Point(mouse_event1.x(),
-                                              mouse_event1.y()));
+  client_session_->LocalMouseMoved(SkIPoint::Make(mouse_event1.x(),
+                                                  mouse_event1.y()));
   client_session_->InjectMouseEvent(mouse_event3);
   // TODO(jamiewalch): Verify that remote inputs are re-enabled eventually
   // (via dependency injection, not sleep!)
   client_session_->OnDisconnected();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   protocol::KeyEvent key1;
   key1.set_pressed(true);
   key1.set_keycode(1);
@@ skipping 12 matching lines @@
 
   EXPECT_CALL(input_stub_, InjectKeyEvent(EqualsKeyEvent(1, false)));
   EXPECT_CALL(input_stub_, InjectKeyEvent(EqualsKeyEvent(2, false)));
   EXPECT_CALL(input_stub_, InjectMouseEvent(EqualsMouseUpEvent(
       protocol::MouseEvent::BUTTON_LEFT)));
 
   client_session_->RestoreEventState();
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
-  gfx::Size screen(200, 100);
+  SkISize screen(SkISize::Make(200, 100));
   EXPECT_CALL(capturer_, size_most_recent())
       .WillRepeatedly(ReturnRef(screen));
 
   protocol::LocalLoginCredentials credentials;
   credentials.set_type(protocol::PASSWORD);
   credentials.set_username("user");
   credentials.set_credential("password");
   EXPECT_CALL(*user_authenticator_, Authenticate(_, _))
       .WillOnce(Return(true));
   EXPECT_CALL(session_event_handler_, LocalLoginSucceeded(_));
@@ skipping 10 matching lines @@
       event.set_x(input_x[i]);
       event.set_y(input_y[j]);
       EXPECT_CALL(input_stub_, InjectMouseEvent(EqualsMouseEvent(
           expected_x[i], expected_y[j])));
       client_session_->InjectMouseEvent(event);
     }
   }
 }
 
 }  // namespace remoting