Use standard DOM code definitions instead of custom.

remoting/protocol/input_event_tracker.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 "remoting/protocol/input_event_tracker.h"
 
 #include "base/logging.h"
 #include "remoting/proto/event.pb.h"
-#include "remoting/protocol/usb_key_codes.h"
 
 namespace remoting {
 namespace protocol {
 
 InputEventTracker::InputEventTracker(InputStub* input_stub)
     : input_stub_(input_stub),
       mouse_button_state_(0) {
 }
 
 InputEventTracker::~InputEventTracker() {}
 
-bool InputEventTracker::IsKeyPressed(uint32 usb_keycode) const {
+bool InputEventTracker::IsKeyPressed(ui::DomCode usb_keycode) const {
   return pressed_keys_.find(usb_keycode) != pressed_keys_.end();
 }
 
 int InputEventTracker::PressedKeyCount() const {
   return pressed_keys_.size();
 }
 
 void InputEventTracker::ReleaseAll() {
   // Release all pressed keys.
-  for (uint32 keycode : pressed_keys_) {
+  for (auto keycode : pressed_keys_) {
     KeyEvent event;
     event.set_pressed(false);
-    event.set_usb_keycode(keycode);
+    event.set_usb_keycode(static_cast<unsigned int>(keycode));

[Sergey Ulanov, 2015/10/12 21:45:57]

use uint32_t instead of unsigned int.

[Jamie, 2015/10/12 22:26:09]

Done.

     input_stub_->InjectKeyEvent(event);
   }
   pressed_keys_.clear();
 
   // Release all mouse buttons.
   for (int i = MouseEvent::BUTTON_UNDEFINED + 1;
        i < MouseEvent::BUTTON_MAX; ++i) {
     if (mouse_button_state_ & (1 << (i - 1))) {
       MouseEvent mouse;
 
@@ skipping 21 matching lines @@
     touch_point_ids_.clear();
   }
   DCHECK(touch_point_ids_.empty());
 }
 
 void InputEventTracker::ReleaseAllIfModifiersStuck(bool alt_expected,
                                                    bool ctrl_expected,
                                                    bool os_expected,
                                                    bool shift_expected) {
   bool alt_down =
-      pressed_keys_.find(kUsbLeftAlt) != pressed_keys_.end() ||
-      pressed_keys_.find(kUsbRightAlt) != pressed_keys_.end();
+      pressed_keys_.find(ui::DomCode::ALT_LEFT) != pressed_keys_.end() ||
+      pressed_keys_.find(ui::DomCode::ALT_RIGHT) != pressed_keys_.end();
   bool ctrl_down =
-      pressed_keys_.find(kUsbLeftControl) != pressed_keys_.end() ||
-      pressed_keys_.find(kUsbRightControl) != pressed_keys_.end();
+      pressed_keys_.find(ui::DomCode::CONTROL_LEFT) != pressed_keys_.end() ||
+      pressed_keys_.find(ui::DomCode::CONTROL_RIGHT) != pressed_keys_.end();
   bool os_down =
-      pressed_keys_.find(kUsbLeftOs) != pressed_keys_.end() ||
-      pressed_keys_.find(kUsbRightOs) != pressed_keys_.end();
+      pressed_keys_.find(ui::DomCode::OS_LEFT) != pressed_keys_.end() ||
+      pressed_keys_.find(ui::DomCode::OS_RIGHT) != pressed_keys_.end();
   bool shift_down =
-      pressed_keys_.find(kUsbLeftShift) != pressed_keys_.end() ||
-      pressed_keys_.find(kUsbRightShift) != pressed_keys_.end();
+      pressed_keys_.find(ui::DomCode::SHIFT_LEFT) != pressed_keys_.end() ||
+      pressed_keys_.find(ui::DomCode::SHIFT_RIGHT) != pressed_keys_.end();
 
   if ((alt_down && !alt_expected) || (ctrl_down && !ctrl_expected) ||
       (os_down && !os_expected) || (shift_down && !shift_expected)) {
     ReleaseAll();
   }
 }
 
 void InputEventTracker::InjectKeyEvent(const KeyEvent& event) {
   // We don't need to track the keyboard lock states of key down events.
   // Pressed keys will be released with |lock_states| set to 0.
   // The lock states of auto generated key up events don't matter as long as
   // we release all the pressed keys at blurring/disconnection time.
   if (event.has_pressed()) {
     if (event.has_usb_keycode()) {
       if (event.pressed()) {
-        pressed_keys_.insert(event.usb_keycode());
+        pressed_keys_.insert(static_cast<ui::DomCode>(event.usb_keycode()));
       } else {
-        pressed_keys_.erase(event.usb_keycode());
+        pressed_keys_.erase(static_cast<ui::DomCode>(event.usb_keycode()));
       }
     }
   }
   input_stub_->InjectKeyEvent(event);
 }
 
 void InputEventTracker::InjectTextEvent(const TextEvent& event) {
   input_stub_->InjectTextEvent(event);
 }
 
@@ skipping 36 matching lines @@
       }
       break;
     default:
       break;
   }
   input_stub_->InjectTouchEvent(event);
 }
 
 }  // namespace protocol
 }  // namespace remoting