Remove support for Windows-style keycodes.

remoting/host/client_session_unittest.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 "base/message_loop.h"
 #include "remoting/base/constants.h"
 #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"
@@ skipping 98 matching lines @@
   client_session_->OnConnectionAuthenticated(client_session_->connection());
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
   // This event should get through to the clipboard stub.
   connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event2);
   DisconnectClientSession();
   // This event should not get through to the clipboard stub,
   // because the client has disconnected.
   connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event3);
 }
 
-MATCHER_P2(EqualsKeyEvent, keycode, pressed, "") {
-  return arg.keycode() == keycode && arg.pressed() == pressed;
+MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") {
+  return arg.usb_keycode() == (unsigned int)usb_keycode &&
+         arg.pressed() == pressed;
 }
 
 MATCHER_P2(EqualsMouseEvent, x, y, "") {
   return arg.x() == x && arg.y() == y;
 }
 
 MATCHER_P2(EqualsMouseButtonEvent, button, down, "") {
   return arg.button() == button && arg.button_down() == down;
 }
 
 TEST_F(ClientSessionTest, InputStubFilter) {
   protocol::KeyEvent key_event1;
   key_event1.set_pressed(true);
-  key_event1.set_keycode(1);
+  key_event1.set_usb_keycode(1);
 
   protocol::KeyEvent key_event2_down;
   key_event2_down.set_pressed(true);
-  key_event2_down.set_keycode(2);
+  key_event2_down.set_usb_keycode(2);
 
   protocol::KeyEvent key_event2_up;
   key_event2_up.set_pressed(false);
-  key_event2_up.set_keycode(2);
+  key_event2_up.set_usb_keycode(2);
 
   protocol::KeyEvent key_event3;
   key_event3.set_pressed(true);
-  key_event3.set_keycode(3);
+  key_event3.set_usb_keycode(3);
 
   protocol::MouseEvent mouse_event1;
   mouse_event1.set_x(100);
   mouse_event1.set_y(101);
 
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
 
   protocol::MouseEvent mouse_event3;
   mouse_event3.set_x(300);
   mouse_event3.set_y(301);
 
   InSequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(2, true)));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(2, false)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(2, true)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(2, false)));
   EXPECT_CALL(host_input_stub_, InjectMouseEvent(EqualsMouseEvent(200, 201)));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
   // These events should not get through to the input stub,
   // because the client isn't authenticated yet.
   connection_->input_stub()->InjectKeyEvent(key_event1);
   connection_->input_stub()->InjectMouseEvent(mouse_event1);
   client_session_->OnConnectionAuthenticated(client_session_->connection());
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
   // These events should get through to the input stub.
@@ skipping 38 matching lines @@
                                                   mouse_event1.y()));
   connection_->input_stub()->InjectMouseEvent(mouse_event3);
   // TODO(jamiewalch): Verify that remote inputs are re-enabled eventually
   // (via dependency injection, not sleep!)
   DisconnectClientSession();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   protocol::KeyEvent key1;
   key1.set_pressed(true);
-  key1.set_keycode(1);
+  key1.set_usb_keycode(1);
 
   protocol::KeyEvent key2;
   key2.set_pressed(true);
-  key2.set_keycode(2);
+  key2.set_usb_keycode(2);
 
   protocol::MouseEvent mousedown;
   mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT);
   mousedown.set_button_down(true);
 
   InSequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(1, true)));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(2, true)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(1, true)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(2, true)));
   EXPECT_CALL(host_input_stub_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, true)));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(1, false)));
-  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsKeyEvent(2, false)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(1, false)));
+  EXPECT_CALL(host_input_stub_, InjectKeyEvent(EqualsUsbEvent(2, false)));
   EXPECT_CALL(host_input_stub_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, false)));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
   client_session_->OnConnectionAuthenticated(client_session_->connection());
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
 
   connection_->input_stub()->InjectKeyEvent(key1);
   connection_->input_stub()->InjectKeyEvent(key2);
   connection_->input_stub()->InjectMouseEvent(mousedown);
@@ skipping 26 matching lines @@
       EXPECT_CALL(host_input_stub_, InjectMouseEvent(EqualsMouseEvent(
           expected_x[i], expected_y[j])));
       connection_->input_stub()->InjectMouseEvent(event);
     }
   }
 
   DisconnectClientSession();
 }
 
 }  // namespace remoting