Move the keyboard files from base/ to app/.

Also moves the associated classes/enums from base:: to app::. TEST=try bots compile BUG=NONE Review URL: http://codereview.chromium.org/3165064 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@58186 0039d316-1c4b-4281-b951-d872f2087c98
author: bryeung@chromium.org <bryeung@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2010-09-01 16:39:26 +0000
committer: bryeung@chromium.org <bryeung@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2010-09-01 16:39:26 +0000
commit: 1eed61535cb6e15015edac43177ccdc25140855a (patch)
tree: 843a3c3b42bfaadc54cd6c835e4c313965a0e177
parent: de6aadf4ddf69c76ddd60e03451fdbcb4061283f (diff)
download: chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.zip
chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.tar.gz
chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.tar.bz2
145 files changed, 1165 insertions, 1114 deletions
diff --git a/app/app_base.gypi b/app/app_base.gypi
index adefed77..f02d190 100644
--- a/app/app_base.gypi
+++ b/app/app_base.gypi
@@ -116,6 +116,8 @@
         'drag_drop_types_gtk.cc',
         'drag_drop_types_win.cc',
         'drag_drop_types.h',
+        'event_synthesis_gtk.cc',
+        'event_synthesis_gtk.h',
         'file_download_interface.h',
         'gfx/font_util.h',
         'gfx/font_util.cc',
@@ -144,6 +146,17 @@
         'gtk_signal_registrar.h',
         'gtk_util.cc',
         'gtk_util.h',
+        'keyboard_code_conversion.cc',
+        'keyboard_code_conversion.h',
+        'keyboard_code_conversion_gtk.cc',
+        'keyboard_code_conversion_gtk.h',
+        'keyboard_code_conversion_mac.mm',
+        'keyboard_code_conversion_mac.h',
+        'keyboard_code_conversion_win.cc',
+        'keyboard_code_conversion_win.h',
+        'keyboard_codes.h',
+        'keyboard_codes_win.h',
+        'keyboard_codes_posix.h',
         'l10n_util.cc',
         'l10n_util.h',
         'l10n_util_mac.h',
@@ -305,6 +318,11 @@
             '<(gl_binding_output_dir)/gl_bindings_autogen_glx.cc',
             '<(gl_binding_output_dir)/gl_bindings_autogen_glx.h',
           ],
+          'sources!': [
+            'keyboard_code_conversion_mac.mm',
+            'keyboard_code_conversion_mac.h',
+            'keyboard_codes_win.h',
+          ],
           'include_dirs': [
             # We don't use angle, but pull the EGL/GLES headers from there.
             '../third_party/angle/include',
@@ -330,6 +348,13 @@
               '$(SDKROOT)/System/Library/Frameworks/OpenGL.framework',
             ],
           },
+          'sources!': [
+            'event_synthesis_gtk.cc',
+            'event_synthesis_gtk.h',
+            'keyboard_code_conversion_gtk.cc',
+            'keyboard_code_conversion_gtk.h',
+            'keyboard_codes_win.h',
+          ],
         }],
         ['OS=="win"', {
           'include_dirs': [
@@ -343,6 +368,15 @@
             '<(gl_binding_output_dir)/gl_bindings_autogen_wgl.cc',
             '<(gl_binding_output_dir)/gl_bindings_autogen_wgl.h',
           ],
+          'sources!': [
+            'event_synthesis_gtk.cc',
+            'event_synthesis_gtk.h',
+            'keyboard_code_conversion_gtk.cc',
+            'keyboard_code_conversion_gtk.h',
+            'keyboard_code_conversion_mac.mm',
+            'keyboard_code_conversion_mac.h',
+            'keyboard_codes_posix.h',
+          ],
         }],
       ],
     },
diff --git a/base/event_synthesis_gtk.cc b/app/event_synthesis_gtk.cc
index 2055909..9163fcc 100644
--- a/base/event_synthesis_gtk.cc
+++ b/app/event_synthesis_gtk.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/event_synthesis_gtk.h"
+#include "app/event_synthesis_gtk.h"
 
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 
-namespace base {
+namespace app {
 
 GdkEvent* SynthesizeKeyEvent(GdkWindow* window,
                              bool press, guint gdk_key, guint state) {
@@ -39,7 +39,7 @@ GdkEvent* SynthesizeKeyEvent(GdkWindow* window,
 }
 
 void SynthesizeKeyPressEvents(GdkWindow* window,
-                              base::KeyboardCode key,
+                              app::KeyboardCode key,
                               bool control, bool shift, bool alt,
                               std::vector<GdkEvent*>* events) {
   if (control)
@@ -64,7 +64,7 @@ void SynthesizeKeyPressEvents(GdkWindow* window,
                 (shift ? GDK_SHIFT_MASK : 0) |
                 (alt ? GDK_MOD1_MASK : 0);
 
-  guint gdk_key = base::GdkKeyCodeForWindowsKeyCode(key, shift);
+  guint gdk_key = GdkKeyCodeForWindowsKeyCode(key, shift);
   events->push_back(SynthesizeKeyEvent(window, true, gdk_key, state));
   events->push_back(SynthesizeKeyEvent(window, false, gdk_key, state));
 
@@ -87,4 +87,4 @@ void SynthesizeKeyPressEvents(GdkWindow* window,
   }
 }
 
-}  // namespace base
+}  // namespace app
diff --git a/base/event_synthesis_gtk.h b/app/event_synthesis_gtk.h
index 9612ae1..72d8279 100644
--- a/base/event_synthesis_gtk.h
+++ b/app/event_synthesis_gtk.h
@@ -6,17 +6,17 @@
 // only keyboard events). This is useful for a variety of testing purposes.
 // NOTE: This should not be used outside of testing.
 
-#ifndef BASE_EVENT_SYNTHESIS_GTK_
-#define BASE_EVENT_SYNTHESIS_GTK_
+#ifndef APP_EVENT_SYNTHESIS_GTK_
+#define APP_EVENT_SYNTHESIS_GTK_
 #pragma once
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <vector>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
-namespace base {
+namespace app {
 
 // Creates and returns a key event. Passes ownership to the caller.
 GdkEvent* SynthesizeKeyEvent(GdkWindow* event_window,
@@ -28,10 +28,10 @@ GdkEvent* SynthesizeKeyEvent(GdkWindow* event_window,
 // Ownership of the events in the vector is passed to the caller.
 void SynthesizeKeyPressEvents(
     GdkWindow* window,
-    base::KeyboardCode key,
+    app::KeyboardCode key,
     bool control, bool shift, bool alt,
     std::vector<GdkEvent*>* events);
 
-}  // namespace base
+}  // namespace app
 
-#endif  // BASE_EVENT_SYNTHESIS_GTK_
+#endif  // APP_EVENT_SYNTHESIS_GTK_
diff --git a/base/keyboard_code_conversion.cc b/app/keyboard_code_conversion.cc
index 31f3c14..00f3c83 100644
--- a/base/keyboard_code_conversion.cc
+++ b/app/keyboard_code_conversion.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_code_conversion.h"
+#include "app/keyboard_code_conversion.h"
 
 #include <string.h>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
-namespace base {
+namespace app {
 
 namespace {
 
@@ -293,4 +293,4 @@ KeyboardCode KeyCodeFromKeyIdentifier(const std::string& key_identifier) {
   return id->key_code;
 }
 
-}  // namespace base
+}  // namespace app
diff --git a/base/keyboard_code_conversion.h b/app/keyboard_code_conversion.h
index 1324d52..4867c1b 100644
--- a/base/keyboard_code_conversion.h
+++ b/app/keyboard_code_conversion.h
@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BASE_KEYBOARD_CODE_CONVERSION_H_
-#define BASE_KEYBOARD_CODE_CONVERSION_H_
+#ifndef APP_KEYBOARD_CODE_CONVERSION_H_
+#define APP_KEYBOARD_CODE_CONVERSION_H_
 #pragma once
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
 #include <string>
 
-namespace base {
+namespace app {
 
 // Convert a KeyIdentifer (see Section 6.3.3 here:
 // http://www.w3.org/TR/DOM-Level-3-Events/#keyset-keyidentifiers)
-// to a base::KeyboardCode.
+// to a app::KeyboardCode.
 KeyboardCode KeyCodeFromKeyIdentifier(const std::string& key_identifier);
 
 }  // namespace
 
-#endif  // BASE_KEYBOARD_CODE_CONVERSION_H_
+#endif  // APP_KEYBOARD_CODE_CONVERSION_H_
diff --git a/base/keyboard_code_conversion_gtk.cc b/app/keyboard_code_conversion_gtk.cc
index 83f4197..5a4b9d7 100644
--- a/base/keyboard_code_conversion_gtk.cc
+++ b/app/keyboard_code_conversion_gtk.cc
@@ -33,15 +33,15 @@
 
 // WindowsKeyCodeForGdkKeyCode is copied from platform/gtk/KeyEventGtk.cpp
 
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
-#include "base/keyboard_codes_posix.h"
+#include "app/keyboard_codes_posix.h"
 
-namespace base {
+namespace app {
 
-base::KeyboardCode WindowsKeyCodeForGdkKeyCode(int keycode) {
+app::KeyboardCode WindowsKeyCodeForGdkKeyCode(int keycode) {
   switch (keycode) {
     case GDK_KP_0:
       return VKEY_NUMPAD0;  // (60) Numeric keypad 0 key
@@ -403,14 +403,14 @@ base::KeyboardCode WindowsKeyCodeForGdkKeyCode(int keycode) {
     case GDK_F22:
     case GDK_F23:
     case GDK_F24:
-      return static_cast<base::KeyboardCode>(VKEY_F1 + (keycode - GDK_F1));
+      return static_cast<app::KeyboardCode>(VKEY_F1 + (keycode - GDK_F1));
     default:
       return VKEY_UNKNOWN;
     }
 }
 
 // TODO(jcampan): this method might be incomplete.
-int GdkKeyCodeForWindowsKeyCode(base::KeyboardCode keycode, bool shift) {
+int GdkKeyCodeForWindowsKeyCode(app::KeyboardCode keycode, bool shift) {
   switch (keycode) {
     case VKEY_NUMPAD0:
       return GDK_KP_0;
@@ -614,4 +614,4 @@ int GdkKeyCodeForWindowsKeyCode(base::KeyboardCode keycode, bool shift) {
     }
 }
 
-}  // namespace base
+}  // namespace app
diff --git a/base/keyboard_code_conversion_gtk.h b/app/keyboard_code_conversion_gtk.h
index 4095b4a..4530562 100644
--- a/base/keyboard_code_conversion_gtk.h
+++ b/app/keyboard_code_conversion_gtk.h
@@ -33,18 +33,18 @@
 
 // WindowsKeyCodeForGdkKeyCode is copied from platform/gtk/KeyEventGtk.cpp
 
-#ifndef BASE_KEYBOARD_CODE_CONVERSION_GTK_H_
-#define BASE_KEYBOARD_CODE_CONVERSION_GTK_H_
+#ifndef APP_KEYBOARD_CODE_CONVERSION_GTK_H_
+#define APP_KEYBOARD_CODE_CONVERSION_GTK_H_
 #pragma once
 
-#include "base/keyboard_codes_posix.h"
+#include "app/keyboard_codes_posix.h"
 
-namespace base {
+namespace app {
 
-base::KeyboardCode WindowsKeyCodeForGdkKeyCode(int keycode);
+app::KeyboardCode WindowsKeyCodeForGdkKeyCode(int keycode);
 
-int GdkKeyCodeForWindowsKeyCode(base::KeyboardCode keycode, bool shift);
+int GdkKeyCodeForWindowsKeyCode(app::KeyboardCode keycode, bool shift);
 
 } // namespace
 
-#endif  // BASE_KEYBOARD_CODE_CONVERSION_GTK_H_
+#endif  // APP_KEYBOARD_CODE_CONVERSION_GTK_H_
diff --git a/base/keyboard_code_conversion_mac.h b/app/keyboard_code_conversion_mac.h
index 9db6e47..2082c83 100644
--- a/base/keyboard_code_conversion_mac.h
+++ b/app/keyboard_code_conversion_mac.h
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BASE_KEYBOARD_CODE_CONVERSION_MAC_H_
-#define BASE_KEYBOARD_CODE_CONVERSION_MAC_H_
+#ifndef APP_KEYBOARD_CODE_CONVERSION_MAC_H_
+#define APP_KEYBOARD_CODE_CONVERSION_MAC_H_
 
 #import <Cocoa/Cocoa.h>
-#include "basictypes.h"
-#include "base/keyboard_codes_posix.h"
+#include "app/keyboard_codes_posix.h"
+#include "base/basictypes.h"
 
-namespace base {
+namespace app {
 
 // We use windows virtual keycodes throughout our keyboard event related code,
 // including unit tests. But Mac uses a different set of virtual keycodes.
@@ -29,6 +29,6 @@ int MacKeyCodeForWindowsKeyCode(KeyboardCode keycode,
                                 unichar* character,
                                 unichar* characterIgnoringModifiers);
 
-} // namespace base
+} // namespace app
 
-#endif  // BASE_KEYBOARD_CODE_CONVERSION_MAC_H_
+#endif  // APP_KEYBOARD_CODE_CONVERSION_MAC_H_
diff --git a/base/keyboard_code_conversion_mac.mm b/app/keyboard_code_conversion_mac.mm
index 79c1b19..63d4553 100644
--- a/base/keyboard_code_conversion_mac.mm
+++ b/app/keyboard_code_conversion_mac.mm
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#import "base/keyboard_code_conversion_mac.h"
+#import "app/keyboard_code_conversion_mac.h"
 
 #include <algorithm>
 #import <Carbon/Carbon.h>
 
 #include "base/logging.h"
 
-namespace base {
+namespace app {
 
 namespace {
 
@@ -290,4 +290,4 @@ int MacKeyCodeForWindowsKeyCode(KeyboardCode keycode,
   return macKeycode;
 }
 
-}  // namespace base
+}  // namespace app
diff --git a/app/keyboard_code_conversion_unittest.cc b/app/keyboard_code_conversion_unittest.cc
new file mode 100644
index 0000000..0f8d6af
--- /dev/null
+++ b/app/keyboard_code_conversion_unittest.cc
@@ -0,0 +1,43 @@
+// Copyright (c) 2010 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 "app/keyboard_code_conversion.h"
+#include "app/keyboard_codes.h"
+#include "base/logging.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace app {
+
+TEST(KeyCodeFromKeyIdentifierTest, MatchOnIdentifier) {
+  EXPECT_EQ(app::VKEY_APPS, KeyCodeFromKeyIdentifier("Apps"));
+  EXPECT_EQ(app::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("Nonsense"));
+}
+
+TEST(KeyCodeFromKeyIdentifierTest, MatchOnCharacter) {
+  EXPECT_EQ(app::VKEY_A, KeyCodeFromKeyIdentifier("a"));
+  EXPECT_EQ(app::VKEY_A, KeyCodeFromKeyIdentifier("A"));
+  EXPECT_EQ(app::VKEY_OEM_PERIOD, KeyCodeFromKeyIdentifier(">"));
+
+  std::string non_printing_char(" ");
+  non_printing_char[0] = static_cast<char>(1);
+  EXPECT_EQ(app::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier(non_printing_char));
+}
+
+TEST(KeyCodeFromKeyIdentifierTest, MatchOnUnicodeCodepoint) {
+  EXPECT_EQ(app::VKEY_A, KeyCodeFromKeyIdentifier("U+0041"));
+  EXPECT_EQ(app::VKEY_A, KeyCodeFromKeyIdentifier("U+0061"));
+  EXPECT_EQ(app::VKEY_DELETE, KeyCodeFromKeyIdentifier("U+007F"));
+
+  // this one exists in the map, but has no valid VKEY
+  EXPECT_EQ(app::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("U+030A"));
+
+  // this one is not in the map
+  EXPECT_EQ(app::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("U+0001"));
+}
+
+TEST(KeyCodeFromKeyIdentifierTest, DoesNotMatchEmptyString) {
+  EXPECT_EQ(app::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier(""));
+}
+
+}  // namespace app
diff --git a/app/keyboard_code_conversion_win.cc b/app/keyboard_code_conversion_win.cc
new file mode 100644
index 0000000..2a7da8f
--- /dev/null
+++ b/app/keyboard_code_conversion_win.cc
@@ -0,0 +1,17 @@
+// Copyright (c) 2010 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 "app/keyboard_code_conversion_win.h"
+
+namespace app {
+
+WORD WindowsKeyCodeForKeyboardCode(app::KeyboardCode keycode) {
+  return static_cast<WORD>(keycode);
+}
+
+app::KeyboardCode KeyboardCodeForWindowsKeyCode(WORD keycode) {
+  return static_cast<app::KeyboardCode>(keycode);
+}
+
+}  // namespace app
diff --git a/app/keyboard_code_conversion_win.h b/app/keyboard_code_conversion_win.h
new file mode 100644
index 0000000..eaf3105
--- /dev/null
+++ b/app/keyboard_code_conversion_win.h
@@ -0,0 +1,19 @@
+// Copyright (c) 2010 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.
+
+#ifndef APP_KEYBOARD_CODE_CONVERSION_WIN_H_
+#define APP_KEYBOARD_CODE_CONVERSION_WIN_H_
+#pragma once
+
+#include "app/keyboard_codes.h"
+
+namespace app {
+
+// Methods to convert app::KeyboardCode/Windows virtual key type methods.
+WORD WindowsKeyCodeForKeyboardCode(app::KeyboardCode keycode);
+app::KeyboardCode KeyboardCodeForWindowsKeyCode(WORD keycode);
+
+}  // namespace app
+
+#endif  // APP_KEYBOARD_CODE_CONVERSION_WIN_H_
diff --git a/base/keyboard_codes.h b/app/keyboard_codes.h
index b154ab8..33e983b 100644
--- a/base/keyboard_codes.h
+++ b/app/keyboard_codes.h
@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BASE_KEYBOARD_CODES_H_
-#define BASE_KEYBOARD_CODES_H_
+#ifndef APP_KEYBOARD_CODES_H_
+#define APP_KEYBOARD_CODES_H_
 #pragma once
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
-#include "base/keyboard_codes_win.h"
+#include "app/keyboard_codes_win.h"
 #elif defined(USE_X11) || defined(OS_MACOSX)
-#include "base/keyboard_codes_posix.h"
+#include "app/keyboard_codes_posix.h"
 #endif
 
-#endif  // BASE_KEYBOARD_CODES_H_
+#endif  // APP_KEYBOARD_CODES_H_
diff --git a/base/keyboard_codes_posix.h b/app/keyboard_codes_posix.h
index a1b4d57..666e68a 100644
--- a/base/keyboard_codes_posix.h
+++ b/app/keyboard_codes_posix.h
@@ -28,11 +28,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef BASE_KEYBOARD_CODES_POSIX_H_
-#define BASE_KEYBOARD_CODES_POSIX_H_
+#ifndef APP_KEYBOARD_CODES_POSIX_H_
+#define APP_KEYBOARD_CODES_POSIX_H_
 #pragma once
 
-namespace base {
+namespace app {
 
 typedef enum {
   VKEY_BACK = 0x08,
@@ -205,6 +205,6 @@ typedef enum {
   VKEY_UNKNOWN = 0
 } KeyboardCode;
 
-}  // namespace views
+}  // namespace app
 
-#endif  // BASE_KEYBOARD_CODES_POSIX_H_
+#endif  // APP_KEYBOARD_CODES_POSIX_H_
diff --git a/base/keyboard_codes_win.h b/app/keyboard_codes_win.h
index 5893947..7c76dfd 100644
--- a/base/keyboard_codes_win.h
+++ b/app/keyboard_codes_win.h
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BASE_KEYBOARD_CODES_WIN_H_
-#define BASE_KEYBOARD_CODES_WIN_H_
+#ifndef APP_KEYBOARD_CODES_WIN_H_
+#define APP_KEYBOARD_CODES_WIN_H_
 #pragma once
 
 #include <windows.h>
 
-namespace base {
+namespace app {
 
 typedef enum {
   VKEY_BACK = VK_BACK,
@@ -181,6 +181,6 @@ typedef enum {
   VKEY_UNKNOWN = 0
 } KeyboardCode;
 
-}  // namespace base
+}  // namespace app
 
-#endif  // BASE_KEYBOARD_CODES_WIN_H_
+#endif  // APP_KEYBOARD_CODES_WIN_H_
diff --git a/app/menus/accelerator.h b/app/menus/accelerator.h
index 06adb99..399569b 100644
--- a/app/menus/accelerator.h
+++ b/app/menus/accelerator.h
@@ -6,7 +6,7 @@
 #define APP_MENUS_ACCELERATOR_H_
 #pragma once
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
 namespace menus {
 
@@ -15,9 +15,9 @@ namespace menus {
 
 class Accelerator {
  public:
-  Accelerator() : key_code_(base::VKEY_UNKNOWN), modifiers_(0) {}
+  Accelerator() : key_code_(app::VKEY_UNKNOWN), modifiers_(0) {}
 
-  Accelerator(base::KeyboardCode keycode, int modifiers)
+  Accelerator(app::KeyboardCode keycode, int modifiers)
       : key_code_(keycode),
         modifiers_(modifiers) {}
 
@@ -52,7 +52,7 @@ class Accelerator {
     return !(*this == rhs);
   }
 
-  base::KeyboardCode GetKeyCode() const {
+  app::KeyboardCode GetKeyCode() const {
     return key_code_;
   }
 
@@ -62,7 +62,7 @@ class Accelerator {
 
  protected:
   // The keycode (VK_...).
-  base::KeyboardCode key_code_;
+  app::KeyboardCode key_code_;
 
   // The state of the Shift/Ctrl/Alt keys (platform-dependent).
   int modifiers_;
diff --git a/app/menus/accelerator_cocoa.h b/app/menus/accelerator_cocoa.h
index 3eb879f..71227fe 100644
--- a/app/menus/accelerator_cocoa.h
+++ b/app/menus/accelerator_cocoa.h
@@ -20,7 +20,7 @@ namespace menus {
 class AcceleratorCocoa : public Accelerator {
  public:
   AcceleratorCocoa(NSString* key_code, NSUInteger mask)
-      : Accelerator(base::VKEY_UNKNOWN, mask),
+      : Accelerator(app::VKEY_UNKNOWN, mask),
         characters_([key_code copy]) {
   }
 
diff --git a/app/menus/accelerator_gtk.h b/app/menus/accelerator_gtk.h
index 86c83f7..ca92f03 100644
--- a/app/menus/accelerator_gtk.h
+++ b/app/menus/accelerator_gtk.h
@@ -8,15 +8,15 @@
 
 #include <gdk/gdk.h>
 
+#include "app/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_codes_posix.h"
 #include "app/menus/accelerator.h"
-#include "base/keyboard_code_conversion_gtk.h"
-#include "base/keyboard_codes_posix.h"
 
 namespace menus {
 
 class AcceleratorGtk : public Accelerator {
  public:
-  AcceleratorGtk(base::KeyboardCode key_code,
+  AcceleratorGtk(app::KeyboardCode key_code,
                  bool shift_pressed, bool ctrl_pressed, bool alt_pressed)
       : gdk_keyval_(0) {
     key_code_ = key_code;
@@ -30,7 +30,7 @@ class AcceleratorGtk : public Accelerator {
   }
 
   AcceleratorGtk(guint keyval, GdkModifierType modifier_type) {
-    key_code_ = base::WindowsKeyCodeForGdkKeyCode(keyval);
+    key_code_ = app::WindowsKeyCodeForGdkKeyCode(keyval);
     gdk_keyval_ = keyval;
     modifiers_ = modifier_type;
   }
@@ -42,7 +42,7 @@ class AcceleratorGtk : public Accelerator {
     return gdk_keyval_ > 0 ?
            // The second parameter is false because accelerator keys are
            // expressed in terms of the non-shift-modified key.
-           gdk_keyval_ : base::GdkKeyCodeForWindowsKeyCode(key_code_, false);
+           gdk_keyval_ : app::GdkKeyCodeForWindowsKeyCode(key_code_, false);
   }
 
   GdkModifierType gdk_modifier_type() {
diff --git a/base/base.gyp b/base/base.gyp
index d3ac910..a7a7a1a 100644
--- a/base/base.gyp
+++ b/base/base.gyp
@@ -98,7 +98,6 @@
         'json/json_reader_unittest.cc',
         'json/json_writer_unittest.cc',
         'json/string_escape_unittest.cc',
-        'keyboard_code_conversion_unittest.cc',
         'lazy_instance_unittest.cc',
         'leak_tracker_unittest.cc',
         'linked_list_unittest.cc',
diff --git a/base/base.gypi b/base/base.gypi
index e5d8119..d594972 100644
--- a/base/base.gypi
+++ b/base/base.gypi
@@ -70,8 +70,6 @@
           'event_trace_controller_win.h',
           'event_trace_provider_win.cc',
           'event_trace_provider_win.h',
-          'event_synthesis_gtk.cc',
-          'event_synthesis_gtk.h',
           'file_path.cc',
           'file_path.h',
           'file_util.cc',
@@ -438,15 +436,6 @@
           'hmac_win.cc',
           'image_util.cc',
           'image_util.h',
-          'keyboard_code_conversion.cc',
-          'keyboard_code_conversion.h',
-          'keyboard_code_conversion_gtk.cc',
-          'keyboard_code_conversion_gtk.h',
-          'keyboard_code_conversion_mac.mm',
-          'keyboard_code_conversion_mac.h',
-          'keyboard_codes.h',
-          'keyboard_codes_win.h',
-          'keyboard_codes_posix.h',
           'linux_util.cc',
           'linux_util.h',
           'md5.cc',
diff --git a/base/keyboard_code_conversion_unittest.cc b/base/keyboard_code_conversion_unittest.cc
deleted file mode 100644
index 91e151b..0000000
--- a/base/keyboard_code_conversion_unittest.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2010 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/keyboard_code_conversion.h"
-#include "base/keyboard_codes.h"
-#include "base/logging.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace base {
-
-TEST(KeyCodeFromKeyIdentifierTest, MatchOnIdentifier) {
-  EXPECT_EQ(base::VKEY_APPS, KeyCodeFromKeyIdentifier("Apps"));
-  EXPECT_EQ(base::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("Nonsense"));
-}
-
-TEST(KeyCodeFromKeyIdentifierTest, MatchOnCharacter) {
-  EXPECT_EQ(base::VKEY_A, KeyCodeFromKeyIdentifier("a"));
-  EXPECT_EQ(base::VKEY_A, KeyCodeFromKeyIdentifier("A"));
-  EXPECT_EQ(base::VKEY_OEM_PERIOD, KeyCodeFromKeyIdentifier(">"));
-
-  std::string non_printing_char(" ");
-  non_printing_char[0] = static_cast<char>(1);
-  EXPECT_EQ(base::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier(non_printing_char));
-}
-
-TEST(KeyCodeFromKeyIdentifierTest, MatchOnUnicodeCodepoint) {
-  EXPECT_EQ(base::VKEY_A, KeyCodeFromKeyIdentifier("U+0041"));
-  EXPECT_EQ(base::VKEY_A, KeyCodeFromKeyIdentifier("U+0061"));
-  EXPECT_EQ(base::VKEY_DELETE, KeyCodeFromKeyIdentifier("U+007F"));
-
-  // this one exists in the map, but has no valid VKEY
-  EXPECT_EQ(base::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("U+030A"));
-
-  // this one is not in the map
-  EXPECT_EQ(base::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier("U+0001"));
-}
-
-TEST(KeyCodeFromKeyIdentifierTest, DoesNotMatchEmptyString) {
-  EXPECT_EQ(base::VKEY_UNKNOWN, KeyCodeFromKeyIdentifier(""));
-}
-
-}  // namespace base
diff --git a/base/win_util.cc b/base/win_util.cc
index 4ff89a9..e5e7d52 100644
--- a/base/win_util.cc
+++ b/base/win_util.cc
@@ -385,14 +385,6 @@ std::wstring FormatLastWin32Error() {
   return FormatMessage(GetLastError());
 }
 
-WORD KeyboardCodeToWin(base::KeyboardCode keycode) {
-  return static_cast<WORD>(keycode);
-}
-
-base::KeyboardCode WinToKeyboardCode(WORD keycode) {
-  return static_cast<base::KeyboardCode>(keycode);
-}
-
 bool SetAppIdForPropertyStore(IPropertyStore* property_store,
                               const wchar_t* app_id) {
   DCHECK(property_store);
diff --git a/base/win_util.h b/base/win_util.h
index f580004..46365ae 100644
--- a/base/win_util.h
+++ b/base/win_util.h
@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/keyboard_codes.h"
-
 struct IPropertyStore;
 struct _tagpropertykey;
 typedef _tagpropertykey PROPERTYKEY;
@@ -115,10 +113,6 @@ std::wstring FormatMessage(unsigned messageid);
 // Uses the last Win32 error to generate a human readable message string.
 std::wstring FormatLastWin32Error();
 
-// Methods to convert base::KeyboardCode/Windows virtual key type methods.
-WORD KeyboardCodeToWin(base::KeyboardCode keycode);
-base::KeyboardCode WinToKeyboardCode(WORD keycode);
-
 // Sets the application id in given IPropertyStore. The function is intended
 // for tagging application/chromium shortcut, browser window and jump list for
 // Win7.
diff --git a/chrome/browser/autocomplete/autocomplete_edit_view_browsertest.cc b/chrome/browser/autocomplete/autocomplete_edit_view_browsertest.cc
index 5b00bab..8ffb9cc 100644
--- a/chrome/browser/autocomplete/autocomplete_edit_view_browsertest.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit_view_browsertest.cc
@@ -4,7 +4,7 @@
 
 #include <stdio.h>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
@@ -43,24 +43,24 @@ namespace {
 
 const char kSearchKeyword[] = "foo";
 const wchar_t kSearchKeywordKeys[] = {
-  base::VKEY_F, base::VKEY_O, base::VKEY_O, 0
+  app::VKEY_F, app::VKEY_O, app::VKEY_O, 0
 };
 const char kSearchURL[] = "http://www.foo.com/search?q={searchTerms}";
 const char kSearchShortName[] = "foo";
 const char kSearchText[] = "abc";
 const wchar_t kSearchTextKeys[] = {
-  base::VKEY_A, base::VKEY_B, base::VKEY_C, 0
+  app::VKEY_A, app::VKEY_B, app::VKEY_C, 0
 };
 const char kSearchTextURL[] = "http://www.foo.com/search?q=abc";
 const char kSearchSingleChar[] = "z";
-const wchar_t kSearchSingleCharKeys[] = { base::VKEY_Z, 0 };
+const wchar_t kSearchSingleCharKeys[] = { app::VKEY_Z, 0 };
 const char kSearchSingleCharURL[] = "http://www.foo.com/search?q=z";
 
 const char kHistoryPageURL[] = "chrome://history/#q=abc";
 
 const char kDesiredTLDHostname[] = "www.bar.com";
 const wchar_t kDesiredTLDKeys[] = {
-  base::VKEY_B, base::VKEY_A, base::VKEY_R, 0
+  app::VKEY_B, app::VKEY_A, app::VKEY_R, 0
 };
 
 // Hostnames that shall be blocked by host resolver.
@@ -122,7 +122,7 @@ class AutocompleteEditViewTest : public InProcessBrowserTest,
     ASSERT_TRUE(*edit_view);
   }
 
-  void SendKey(base::KeyboardCode key, bool control, bool shift, bool alt) {
+  void SendKey(app::KeyboardCode key, bool control, bool shift, bool alt) {
     gfx::NativeWindow window = NULL;
     ASSERT_NO_FATAL_FAILURE(GetNativeWindow(&window));
     ASSERT_TRUE(
@@ -132,7 +132,7 @@ class AutocompleteEditViewTest : public InProcessBrowserTest,
 
   void SendKeySequence(const wchar_t* keys) {
     for (; *keys; ++keys)
-      ASSERT_NO_FATAL_FAILURE(SendKey(static_cast<base::KeyboardCode>(*keys),
+      ASSERT_NO_FATAL_FAILURE(SendKey(static_cast<app::KeyboardCode>(*keys),
                                       false, false, false));
   }
 
@@ -299,25 +299,25 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, BrowserAccelerators) {
   ASSERT_NO_FATAL_FAILURE(WaitForTabOpenOrClose(tab_count + 1));
 
   // Select the first Tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_1, true, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_1, true, false, false));
   ASSERT_EQ(0, browser()->selected_index());
 
   browser()->FocusLocationBar();
 
   // Select the second Tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_2, true, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_2, true, false, false));
   ASSERT_EQ(1, browser()->selected_index());
 
   browser()->FocusLocationBar();
 
   // Close a Tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_W, true, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_W, true, false, false));
   ASSERT_NO_FATAL_FAILURE(WaitForTabOpenOrClose(tab_count));
 
   // Try ctrl-l to focus location bar.
   edit_view->SetUserText(L"Hello world");
   EXPECT_FALSE(edit_view->IsSelectAll());
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_L, true, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_L, true, false, false));
   EXPECT_TRUE(edit_view->IsSelectAll());
 }
 
@@ -334,17 +334,17 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, BackspaceInKeywordMode) {
   ASSERT_EQ(kSearchKeyword, WideToUTF8(edit_view->model()->keyword()));
 
   // Trigger keyword mode.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_TAB, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_TAB, false, false, false));
   ASSERT_FALSE(edit_view->model()->is_keyword_hint());
   ASSERT_EQ(kSearchKeyword, WideToUTF8(edit_view->model()->keyword()));
 
   // Backspace without search text should bring back keyword hint mode.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_BACK, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_BACK, false, false, false));
   ASSERT_TRUE(edit_view->model()->is_keyword_hint());
   ASSERT_EQ(kSearchKeyword, WideToUTF8(edit_view->model()->keyword()));
 
   // Trigger keyword mode again.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_TAB, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_TAB, false, false, false));
   ASSERT_FALSE(edit_view->model()->is_keyword_hint());
   ASSERT_EQ(kSearchKeyword, WideToUTF8(edit_view->model()->keyword()));
 
@@ -354,7 +354,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, BackspaceInKeywordMode) {
   // Should stay in keyword mode while deleting search text by pressing
   // backspace.
   for (size_t i = 0; i < arraysize(kSearchText) - 1; ++i) {
-    ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_BACK, false, false, false));
+    ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_BACK, false, false, false));
     ASSERT_FALSE(edit_view->model()->is_keyword_hint());
     ASSERT_EQ(kSearchKeyword, WideToUTF8(edit_view->model()->keyword()));
   }
@@ -363,10 +363,10 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, BackspaceInKeywordMode) {
   ASSERT_NO_FATAL_FAILURE(SendKeySequence(kSearchTextKeys));
 
   // Move cursor to the beginning of the search text.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_HOME, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_HOME, false, false, false));
   // Backspace at the beginning of the search text shall turn off
   // the keyword mode.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_BACK, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_BACK, false, false, false));
   ASSERT_FALSE(edit_view->model()->is_keyword_hint());
   ASSERT_EQ(std::string(), WideToUTF8(edit_view->model()->keyword()));
   ASSERT_EQ(std::string(kSearchKeyword) + kSearchText,
@@ -386,11 +386,11 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, Escape) {
   EXPECT_TRUE(edit_view->IsSelectAll());
 
   // Delete all text in omnibox.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_BACK, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_BACK, false, false, false));
   EXPECT_TRUE(edit_view->GetText().empty());
 
   // Escape shall revert the text in omnibox.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_ESCAPE, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_ESCAPE, false, false, false));
   EXPECT_EQ(old_text, edit_view->GetText());
   EXPECT_TRUE(edit_view->IsSelectAll());
 }
@@ -409,7 +409,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, DesiredTLD) {
   ASSERT_NO_FATAL_FAILURE(WaitForAutocompleteControllerDone());
   ASSERT_TRUE(popup_model->IsOpen());
   // ctrl-Enter triggers desired_tld feature, thus www.bar.com shall be opened.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_RETURN, true, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_RETURN, true, false, false));
 
   GURL url = browser()->GetSelectedTabContents()->GetURL();
   EXPECT_STREQ(kDesiredTLDHostname, url.host().c_str());
@@ -426,7 +426,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, AltEnter) {
   edit_view->SetUserText(ASCIIToWide(chrome::kChromeUIHistoryURL));
   int tab_count = browser()->tab_count();
   // alt-Enter opens a new tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_RETURN, false, false, true));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_RETURN, false, false, true));
   ASSERT_NO_FATAL_FAILURE(WaitForTabOpenOrClose(tab_count + 1));
 }
 
@@ -450,7 +450,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EnterToSearch) {
             popup_model->result().default_match()->type);
 
   // Open the default match.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_RETURN, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_RETURN, false, false, false));
   GURL url = browser()->GetSelectedTabContents()->GetURL();
   EXPECT_STREQ(kSearchTextURL, url.spec().c_str());
 
@@ -467,7 +467,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EnterToSearch) {
             popup_model->result().default_match()->type);
 
   // Open the default match.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_RETURN, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_RETURN, false, false, false));
   url = browser()->GetSelectedTabContents()->GetURL();
   EXPECT_STREQ(kSearchSingleCharURL, url.spec().c_str());
 }
@@ -495,7 +495,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EnterToOpenHistoryPage) {
         AutocompleteMatch::OPEN_HISTORY_PAGE)
       break;
     size_t old_selected_line = popup_model->selected_line();
-    ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_DOWN, false, false, false));
+    ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_DOWN, false, false, false));
     ASSERT_EQ(old_selected_line + 1, popup_model->selected_line());
     if (popup_model->selected_line() == size - 1)
       break;
@@ -506,7 +506,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EnterToOpenHistoryPage) {
             popup_model->result().match_at(popup_model->selected_line()).type);
 
   // Open the history page item.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_RETURN, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_RETURN, false, false, false));
   GURL url = browser()->GetSelectedTabContents()->GetURL();
   EXPECT_STREQ(kHistoryPageURL, url.spec().c_str());
 }
@@ -536,7 +536,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EscapeToDefaultMatch) {
   // Move to another line with different text.
   size_t size = popup_model->result().size();
   while (popup_model->selected_line() < size - 1) {
-    ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_DOWN, false, false, false));
+    ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_DOWN, false, false, false));
     ASSERT_NE(old_selected_line, popup_model->selected_line());
     if (old_text != edit_view->GetText())
       break;
@@ -545,7 +545,7 @@ IN_PROC_BROWSER_TEST_F(AutocompleteEditViewTest, EscapeToDefaultMatch) {
   EXPECT_NE(old_text, edit_view->GetText());
 
   // Escape shall revert back to the default match item.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_ESCAPE, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_ESCAPE, false, false, false));
   EXPECT_EQ(old_text, edit_view->GetText());
   EXPECT_EQ(old_selected_line, popup_model->selected_line());
 }
diff --git a/chrome/browser/autocomplete/autocomplete_edit_view_win.cc b/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
index 0230fb3..e75ce26 100644
--- a/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
@@ -13,6 +13,7 @@
 
 #include "app/clipboard/clipboard.h"
 #include "app/clipboard/scoped_clipboard_writer.h"
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/os_exchange_data.h"
@@ -24,7 +25,6 @@
 #include "base/basictypes.h"
 #include "base/i18n/rtl.h"
 #include "base/iat_patch.h"
-#include "base/keyboard_codes.h"
 #include "base/lazy_instance.h"
 #include "base/ref_counted.h"
 #include "base/utf_string_conversions.h"
@@ -877,10 +877,10 @@ void AutocompleteEditViewWin::PasteAndGo(const std::wstring& text) {
 
 bool AutocompleteEditViewWin::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& e) {
-  base::KeyboardCode key = e.GetKeyCode();
+  app::KeyboardCode key = e.GetKeyCode();
   // We don't process ALT + numpad digit as accelerators, they are used for
   // entering special characters.  We do translate alt-home.
-  if (e.IsAltDown() && (key != base::VKEY_HOME) &&
+  if (e.IsAltDown() && (key != app::VKEY_HOME) &&
       win_util::IsNumPadDigit(key, e.IsExtendedKey()))
     return true;
 
@@ -892,28 +892,28 @@ bool AutocompleteEditViewWin::SkipDefaultKeyEventProcessing(
   // accelerators (e.g., F5 for reload the page should work even when the
   // Omnibox gets focused).
   switch (key) {
-    case base::VKEY_ESCAPE: {
+    case app::VKEY_ESCAPE: {
       ScopedFreeze freeze(this, GetTextObjectModel());
       return model_->OnEscapeKeyPressed();
     }
 
-    case base::VKEY_RETURN:
+    case app::VKEY_RETURN:
       return true;
 
-    case base::VKEY_UP:
-    case base::VKEY_DOWN:
+    case app::VKEY_UP:
+    case app::VKEY_DOWN:
       return !e.IsAltDown();
 
-    case base::VKEY_DELETE:
-    case base::VKEY_INSERT:
+    case app::VKEY_DELETE:
+    case app::VKEY_INSERT:
       return !e.IsAltDown() && e.IsShiftDown() && !e.IsControlDown();
 
-    case base::VKEY_X:
-    case base::VKEY_V:
+    case app::VKEY_X:
+    case app::VKEY_V:
       return !e.IsAltDown() && e.IsControlDown();
 
-    case base::VKEY_BACK:
-    case base::VKEY_OEM_PLUS:
+    case app::VKEY_BACK:
+    case app::VKEY_OEM_PLUS:
       return true;
 
     default:
@@ -1761,7 +1761,7 @@ void AutocompleteEditViewWin::HandleKeystroke(UINT message,
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
 
-  if (key == base::VKEY_HOME || key == base::VKEY_END) {
+  if (key == app::VKEY_HOME || key == app::VKEY_END) {
     // DefWindowProc() might reset the keyboard layout when it receives a
     // keydown event for VKEY_HOME or VKEY_END. When the window was created
     // with WS_EX_LAYOUTRTL and the current keyboard layout is not a RTL one,
diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index e2f5d12..8a27a77 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -12,7 +12,6 @@
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/json/string_escape.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
diff --git a/chrome/browser/automation/automation_provider_win.cc b/chrome/browser/automation/automation_provider_win.cc
index 41994e8..3495991 100644
--- a/chrome/browser/automation/automation_provider_win.cc
+++ b/chrome/browser/automation/automation_provider_win.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/automation/automation_provider.h"
 
+#include "app/keyboard_codes.h"
 #include "base/json/json_reader.h"
-#include "base/keyboard_codes.h"
 #include "base/trace_event.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/automation/automation_browser_tracker.h"
@@ -200,7 +200,7 @@ void AutomationProvider::WindowSimulateDrag(int handle,
 
     if (press_escape_en_route) {
       // Press Escape.
-      ui_controls::SendKeyPress(window, base::VKEY_ESCAPE,
+      ui_controls::SendKeyPress(window, app::VKEY_ESCAPE,
                                ((flags & views::Event::EF_CONTROL_DOWN)
                                 == views::Event::EF_CONTROL_DOWN),
                                ((flags & views::Event::EF_SHIFT_DOWN) ==
diff --git a/chrome/browser/automation/testing_automation_provider.cc b/chrome/browser/automation/testing_automation_provider.cc
index a8ef344b..fd1acf5 100644
--- a/chrome/browser/automation/testing_automation_provider.cc
+++ b/chrome/browser/automation/testing_automation_provider.cc
@@ -878,7 +878,7 @@ void TestingAutomationProvider::WindowSimulateKeyPress(
 
   gfx::NativeWindow window = window_tracker_->GetResource(handle);
   // The key event is sent to whatever window is active.
-  ui_controls::SendKeyPress(window, static_cast<base::KeyboardCode>(key),
+  ui_controls::SendKeyPress(window, static_cast<app::KeyboardCode>(key),
                            ((flags & views::Event::EF_CONTROL_DOWN) ==
                               views::Event::EF_CONTROL_DOWN),
                             ((flags & views::Event::EF_SHIFT_DOWN) ==
diff --git a/chrome/browser/automation/ui_controls.h b/chrome/browser/automation/ui_controls.h
index 2b26dfe..3664567 100644
--- a/chrome/browser/automation/ui_controls.h
+++ b/chrome/browser/automation/ui_controls.h
@@ -12,7 +12,7 @@
 #include <wtypes.h>
 #endif
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "gfx/native_widget_types.h"
 #include "gfx/point.h"
 
@@ -46,13 +46,13 @@ namespace ui_controls {
 // If you're writing a test chances are you want the variant in ui_test_utils.
 // See it for details.
 bool SendKeyPress(gfx::NativeWindow window,
-                  base::KeyboardCode key,
+                  app::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command);
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
-                                base::KeyboardCode key,
+                                app::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
diff --git a/chrome/browser/automation/ui_controls_linux.cc b/chrome/browser/automation/ui_controls_linux.cc
index bdf71df..a2dd0ae 100644
--- a/chrome/browser/automation/ui_controls_linux.cc
+++ b/chrome/browser/automation/ui_controls_linux.cc
@@ -7,8 +7,8 @@
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 
+#include "app/event_synthesis_gtk.h"
 #include "gfx/rect.h"
-#include "base/event_synthesis_gtk.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/automation/ui_controls_internal.h"
@@ -96,7 +96,7 @@ void FakeAMouseMotionEvent(gint x, gint y) {
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
-                  base::KeyboardCode key,
+                  app::KeyboardCode key,
                   bool control, bool shift, bool alt, bool command) {
   DCHECK(command == false);  // No command key on Linux
   GdkWindow* event_window = NULL;
@@ -124,7 +124,7 @@ bool SendKeyPress(gfx::NativeWindow window,
   }
 
   std::vector<GdkEvent*> events;
-  base::SynthesizeKeyPressEvents(event_window, key, control, shift, alt,
+  app::SynthesizeKeyPressEvents(event_window, key, control, shift, alt,
                                  &events);
   for (std::vector<GdkEvent*>::iterator iter = events.begin();
        iter != events.end(); ++iter) {
@@ -137,7 +137,7 @@ bool SendKeyPress(gfx::NativeWindow window,
 }
 
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
-                                base::KeyboardCode key,
+                                app::KeyboardCode key,
                                 bool control, bool shift,
                                 bool alt, bool command,
                                 Task* task) {
diff --git a/chrome/browser/automation/ui_controls_mac.mm b/chrome/browser/automation/ui_controls_mac.mm
index d95dbc2..5edfa5d 100644
--- a/chrome/browser/automation/ui_controls_mac.mm
+++ b/chrome/browser/automation/ui_controls_mac.mm
@@ -8,7 +8,7 @@
 #include <mach/mach_time.h>
 #include <vector>
 
-#include "base/keyboard_code_conversion_mac.h"
+#include "app/keyboard_code_conversion_mac.h"
 #include "base/message_loop.h"
 #include "chrome/browser/automation/ui_controls_internal.h"
 #include "chrome/browser/chrome_thread.h"
@@ -76,11 +76,11 @@ NSTimeInterval TimeIntervalSinceSystemStartup() {
 // Creates and returns an autoreleased key event.
 NSEvent* SynthesizeKeyEvent(NSWindow* window,
                             bool keyDown,
-                            base::KeyboardCode keycode,
+                            app::KeyboardCode keycode,
                             NSUInteger flags) {
   unichar character;
   unichar characterIgnoringModifiers;
-  int macKeycode = base::MacKeyCodeForWindowsKeyCode(
+  int macKeycode = app::MacKeyCodeForWindowsKeyCode(
       keycode, flags, &character, &characterIgnoringModifiers);
 
   if (macKeycode < 0)
@@ -97,8 +97,8 @@ NSEvent* SynthesizeKeyEvent(NSWindow* window,
 
   // Modifier keys generate NSFlagsChanged event rather than
   // NSKeyDown/NSKeyUp events.
-  if (keycode == base::VKEY_CONTROL || keycode == base::VKEY_SHIFT ||
-      keycode == base::VKEY_MENU || keycode == base::VKEY_COMMAND)
+  if (keycode == app::VKEY_CONTROL || keycode == app::VKEY_SHIFT ||
+      keycode == app::VKEY_MENU || keycode == app::VKEY_COMMAND)
     type = NSFlagsChanged;
 
   // For events other than mouse moved, [event locationInWindow] is
@@ -121,7 +121,7 @@ NSEvent* SynthesizeKeyEvent(NSWindow* window,
 
 // Creates the proper sequence of autoreleased key events for a key down + up.
 void SynthesizeKeyEventsSequence(NSWindow* window,
-                                 base::KeyboardCode keycode,
+                                 app::KeyboardCode keycode,
                                  bool control,
                                  bool shift,
                                  bool alt,
@@ -131,25 +131,25 @@ void SynthesizeKeyEventsSequence(NSWindow* window,
   NSUInteger flags = 0;
   if (control) {
     flags |= NSControlKeyMask;
-    event = SynthesizeKeyEvent(window, true, base::VKEY_CONTROL, flags);
+    event = SynthesizeKeyEvent(window, true, app::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (shift) {
     flags |= NSShiftKeyMask;
-    event = SynthesizeKeyEvent(window, true, base::VKEY_SHIFT, flags);
+    event = SynthesizeKeyEvent(window, true, app::VKEY_SHIFT, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (alt) {
     flags |= NSAlternateKeyMask;
-    event = SynthesizeKeyEvent(window, true, base::VKEY_MENU, flags);
+    event = SynthesizeKeyEvent(window, true, app::VKEY_MENU, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (command) {
     flags |= NSCommandKeyMask;
-    event = SynthesizeKeyEvent(window, true, base::VKEY_COMMAND, flags);
+    event = SynthesizeKeyEvent(window, true, app::VKEY_COMMAND, flags);
     DCHECK(event);
     events->push_back(event);
   }
@@ -163,25 +163,25 @@ void SynthesizeKeyEventsSequence(NSWindow* window,
 
   if (command) {
     flags &= ~NSCommandKeyMask;
-    event = SynthesizeKeyEvent(window, false, base::VKEY_COMMAND, flags);
+    event = SynthesizeKeyEvent(window, false, app::VKEY_COMMAND, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (alt) {
     flags &= ~NSAlternateKeyMask;
-    event = SynthesizeKeyEvent(window, false, base::VKEY_MENU, flags);
+    event = SynthesizeKeyEvent(window, false, app::VKEY_MENU, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (shift) {
     flags &= ~NSShiftKeyMask;
-    event = SynthesizeKeyEvent(window, false, base::VKEY_SHIFT, flags);
+    event = SynthesizeKeyEvent(window, false, app::VKEY_SHIFT, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (control) {
     flags &= ~NSControlKeyMask;
-    event = SynthesizeKeyEvent(window, false, base::VKEY_CONTROL, flags);
+    event = SynthesizeKeyEvent(window, false, app::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
@@ -221,7 +221,7 @@ NSPoint g_mouse_location = { 0, 0 };
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
-                  base::KeyboardCode key,
+                  app::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
@@ -234,7 +234,7 @@ bool SendKeyPress(gfx::NativeWindow window,
 // Win and Linux implement a SendKeyPress() this as a
 // SendKeyPressAndRelease(), so we should as well (despite the name).
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
-                                base::KeyboardCode key,
+                                app::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
diff --git a/chrome/browser/automation/ui_controls_win.cc b/chrome/browser/automation/ui_controls_win.cc
index 50bb88f..fdd1732 100644
--- a/chrome/browser/automation/ui_controls_win.cc
+++ b/chrome/browser/automation/ui_controls_win.cc
@@ -4,7 +4,8 @@
 
 #include "chrome/browser/automation/ui_controls.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_code_conversion_win.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/win_util.h"
@@ -137,10 +138,10 @@ void InputDispatcher::NotifyTask() {
 
 // Populate the INPUT structure with the appropriate keyboard event
 // parameters required by SendInput
-bool FillKeyboardInput(base::KeyboardCode key, INPUT* input, bool key_up) {
+bool FillKeyboardInput(app::KeyboardCode key, INPUT* input, bool key_up) {
   memset(input, 0, sizeof(INPUT));
   input->type = INPUT_KEYBOARD;
-  input->ki.wVk = win_util::KeyboardCodeToWin(key);
+  input->ki.wVk = app::WindowsKeyCodeForKeyboardCode(key);
   input->ki.dwFlags = key_up ? KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP :
                                KEYEVENTF_EXTENDEDKEY;
 
@@ -148,7 +149,7 @@ bool FillKeyboardInput(base::KeyboardCode key, INPUT* input, bool key_up) {
 }
 
 // Send a key event (up/down)
-bool SendKeyEvent(base::KeyboardCode key, bool up) {
+bool SendKeyEvent(app::KeyboardCode key, bool up) {
   INPUT input = { 0 };
 
   if (!FillKeyboardInput(key, &input, up))
@@ -160,7 +161,7 @@ bool SendKeyEvent(base::KeyboardCode key, bool up) {
   return true;
 }
 
-bool SendKeyPressImpl(base::KeyboardCode key,
+bool SendKeyPressImpl(app::KeyboardCode key,
                       bool control, bool shift, bool alt,
                       Task* task) {
   scoped_refptr<InputDispatcher> dispatcher(
@@ -171,7 +172,7 @@ bool SendKeyPressImpl(base::KeyboardCode key,
   // exists, send the key event directly there.
   HWND popup_menu = ::FindWindow(L"#32768", 0);
   if (popup_menu != NULL && popup_menu == ::GetTopWindow(NULL)) {
-    WPARAM w_param = win_util::KeyboardCodeToWin(key);
+    WPARAM w_param = app::WindowsKeyCodeForKeyboardCode(key);
     LPARAM l_param = 0;
     ::SendMessage(popup_menu, WM_KEYDOWN, w_param, l_param);
     ::SendMessage(popup_menu, WM_KEYUP, w_param, l_param);
@@ -185,19 +186,19 @@ bool SendKeyPressImpl(base::KeyboardCode key,
 
   UINT i = 0;
   if (control) {
-    if (!FillKeyboardInput(base::VKEY_CONTROL, &input[i], false))
+    if (!FillKeyboardInput(app::VKEY_CONTROL, &input[i], false))
       return false;
     i++;
   }
 
   if (shift) {
-    if (!FillKeyboardInput(base::VKEY_SHIFT, &input[i], false))
+    if (!FillKeyboardInput(app::VKEY_SHIFT, &input[i], false))
       return false;
     i++;
   }
 
   if (alt) {
-    if (!FillKeyboardInput(base::VKEY_MENU, &input[i], false))
+    if (!FillKeyboardInput(app::VKEY_MENU, &input[i], false))
       return false;
     i++;
   }
@@ -211,19 +212,19 @@ bool SendKeyPressImpl(base::KeyboardCode key,
   i++;
 
   if (alt) {
-    if (!FillKeyboardInput(base::VKEY_MENU, &input[i], true))
+    if (!FillKeyboardInput(app::VKEY_MENU, &input[i], true))
       return false;
     i++;
   }
 
   if (shift) {
-    if (!FillKeyboardInput(base::VKEY_SHIFT, &input[i], true))
+    if (!FillKeyboardInput(app::VKEY_SHIFT, &input[i], true))
       return false;
     i++;
   }
 
   if (control) {
-    if (!FillKeyboardInput(base::VKEY_CONTROL, &input[i], true))
+    if (!FillKeyboardInput(app::VKEY_CONTROL, &input[i], true))
       return false;
     i++;
   }
@@ -322,14 +323,14 @@ bool SendMouseEventsImpl(MouseButton type, int state, Task* task) {
 
 // public functions -----------------------------------------------------------
 
-bool SendKeyPress(gfx::NativeWindow window, base::KeyboardCode key,
+bool SendKeyPress(gfx::NativeWindow window, app::KeyboardCode key,
                   bool control, bool shift, bool alt, bool command) {
   DCHECK(command == false);  // No command key on Windows
   return SendKeyPressImpl(key, control, shift, alt, NULL);
 }
 
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
-                                base::KeyboardCode key,
+                                app::KeyboardCode key,
                                 bool control, bool shift, bool alt,
                                 bool command,
                                 Task* task) {
diff --git a/chrome/browser/browser_focus_uitest.cc b/chrome/browser/browser_focus_uitest.cc
index 12515f7..0b7ffa7 100644
--- a/chrome/browser/browser_focus_uitest.cc
+++ b/chrome/browser/browser_focus_uitest.cc
@@ -306,7 +306,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, TabsRememberFocus) {
       ASSERT_TRUE(IsViewFocused(vid));
 
       ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-          window, base::VKEY_TAB, true, false, false, false));
+          window, app::VKEY_TAB, true, false, false, false));
     }
 
     // As above, but with ctrl+shift+tab.
@@ -317,7 +317,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, TabsRememberFocus) {
       ASSERT_TRUE(IsViewFocused(vid));
 
       ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-          window, base::VKEY_TAB, true, true, false, false));
+          window, app::VKEY_TAB, true, true, false, false));
     }
   }
 }
@@ -480,7 +480,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversal) {
           &actual));
       ASSERT_STREQ(kExpElementIDs[j], actual.c_str());
 
-      ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
+      ASSERT_TRUE(ui_controls::SendKeyPress(window, app::VKEY_TAB,
                                             false, false, false, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
@@ -509,7 +509,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversal) {
     // Now let's press shift-tab to move the focus in reverse.
     for (size_t j = 0; j < 7; ++j) {
       SCOPED_TRACE(StringPrintf("inner loop: %" PRIuS, j));
-      ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
+      ASSERT_TRUE(ui_controls::SendKeyPress(window, app::VKEY_TAB,
                                             false, true, false, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
@@ -584,7 +584,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversalOnInterstitial) {
       std::string actual = interstitial_page->GetFocusedElement();
       ASSERT_STREQ(kExpElementIDs[j], actual.c_str());
 
-      ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
+      ASSERT_TRUE(ui_controls::SendKeyPress(window, app::VKEY_TAB,
                                             false, false, false, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
@@ -609,7 +609,7 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, MAYBE_FocusTraversalOnInterstitial) {
 
     // Now let's press shift-tab to move the focus in reverse.
     for (size_t j = 0; j < 7; ++j) {
-      ASSERT_TRUE(ui_controls::SendKeyPress(window, base::VKEY_TAB,
+      ASSERT_TRUE(ui_controls::SendKeyPress(window, app::VKEY_TAB,
                                             false, true, false, false));
 
       if (j < arraysize(kExpElementIDs) - 1) {
@@ -682,11 +682,11 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FindFocusTest) {
 #if defined(OS_MACOSX)
   // Press Cmd+F, which will make the Find box open and request focus.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, false, false, false, true));
+      window, app::VKEY_F, false, false, false, true));
 #else
   // Press Ctrl+F, which will make the Find box open and request focus.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, true, false, false, false));
+      window, app::VKEY_F, true, false, false, false));
 #endif
 
   // Ideally, we wouldn't sleep here and instead would intercept the
@@ -706,10 +706,10 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FindFocusTest) {
   // Now press Ctrl+F again and focus should move to the Find box.
 #if defined(OS_MACOSX)
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, false, false, false, true));
+      window, app::VKEY_F, false, false, false, true));
 #else
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, true, false, false, false));
+      window, app::VKEY_F, true, false, false, false));
 #endif
   ASSERT_TRUE(IsViewFocused(VIEW_ID_FIND_IN_PAGE_TEXT_FIELD));
 
@@ -720,10 +720,10 @@ IN_PROC_BROWSER_TEST_F(BrowserFocusTest, FindFocusTest) {
   // Now press Ctrl+F again and focus should move to the Find box.
 #if defined(OS_MACOSX)
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, false, false, false, true));
+      window, app::VKEY_F, false, false, false, true));
 #else
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F, true, false, false, false));
+      window, app::VKEY_F, true, false, false, false));
 #endif
 
   // See remark above on why we wait.
diff --git a/chrome/browser/browser_keyevents_browsertest.cc b/chrome/browser/browser_keyevents_browsertest.cc
index 87a6bedf..8656e22 100644
--- a/chrome/browser/browser_keyevents_browsertest.cc
+++ b/chrome/browser/browser_keyevents_browsertest.cc
@@ -4,8 +4,8 @@
 
 #include "build/build_config.h"
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ -63,7 +63,7 @@ const size_t kMaxResultLength = 10;
 // input.
 // Please refer to chrome/test/data/keyevents_test.html for details.
 struct KeyEventTestData {
-  base::KeyboardCode key;
+  app::KeyboardCode key;
   bool ctrl;
   bool shift;
   bool alt;
@@ -142,7 +142,7 @@ class BrowserKeyEventsTest : public InProcessBrowserTest {
     ui_test_utils::ShowAndFocusNativeWindow(window);
   }
 
-  void SendKey(base::KeyboardCode key,
+  void SendKey(app::KeyboardCode key,
                bool control,
                bool shift,
                bool alt,
@@ -315,13 +315,13 @@ class BrowserKeyEventsTest : public InProcessBrowserTest {
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, NormalKeyEvents) {
   static const KeyEventTestData kTestNoInput[] = {
     // a
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       false, false, false, false, 3,
       { "D 65 0 false false false false",
         "P 97 97 false false false false",
         "U 65 0 false false false false" } },
     // shift-a
-    { base::VKEY_A, false, true, false, false,
+    { app::VKEY_A, false, true, false, false,
       false, false, false, false, 5,
       { "D 16 0 false true false false",
         "D 65 0 false true false false",
@@ -329,7 +329,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, NormalKeyEvents) {
         "U 65 0 false true false false",
         "U 16 0 false true false false" } },
     // a, suppress keydown
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       true, false, false, false, 2,
       { "D 65 0 false false false false",
         "U 65 0 false false false false" } },
@@ -337,14 +337,14 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, NormalKeyEvents) {
 
   static const KeyEventTestData kTestWithInput[] = {
     // a
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       false, false, false, false, 4,
       { "D 65 0 false false false false",
         "P 97 97 false false false false",
         "T a",
         "U 65 0 false false false false" } },
     // shift-a
-    { base::VKEY_A, false, true, false, false,
+    { app::VKEY_A, false, true, false, false,
       false, false, false, false, 6,
       { "D 16 0 false true false false",
         "D 65 0 false true false false",
@@ -353,18 +353,18 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, NormalKeyEvents) {
         "U 65 0 false true false false",
         "U 16 0 false true false false" } },
     // a, suppress keydown
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       true, false, false, false, 2,
       { "D 65 0 false false false false",
         "U 65 0 false false false false" } },
     // a, suppress keypress
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       false, true, false, false, 3,
       { "D 65 0 false false false false",
         "P 97 97 false false false false",
         "U 65 0 false false false false" } },
     // a, suppress textInput
-    { base::VKEY_A, false, false, false, false,
+    { app::VKEY_A, false, false, false, false,
       false, false, false, true, 4,
       { "D 65 0 false false false false",
         "P 97 97 false false false false",
@@ -410,14 +410,14 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, NormalKeyEvents) {
 #if defined(OS_WIN) || defined(OS_LINUX)
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
   static const KeyEventTestData kTestCtrlF = {
-    base::VKEY_F, true, false, false, false,
+    app::VKEY_F, true, false, false, false,
     false, false, false, false, 2,
     { "D 17 0 true false false false",
       "D 70 0 true false false false" }
   };
 
   static const KeyEventTestData kTestCtrlFSuppressKeyDown = {
-    base::VKEY_F, true, false, false, false,
+    app::VKEY_F, true, false, false, false,
     true, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 70 0 true false false false",
@@ -428,7 +428,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
   // Ctrl+Z doesn't bind to any accelerators, which then should generate a
   // keypress event with charCode=26.
   static const KeyEventTestData kTestCtrlZ = {
-    base::VKEY_Z, true, false, false, false,
+    app::VKEY_Z, true, false, false, false,
     false, false, false, false, 5,
     { "D 17 0 true false false false",
       "D 90 0 true false false false",
@@ -438,7 +438,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
   };
 
   static const KeyEventTestData kTestCtrlZSuppressKeyDown = {
-    base::VKEY_Z, true, false, false, false,
+    app::VKEY_Z, true, false, false, false,
     true, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 90 0 true false false false",
@@ -448,7 +448,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
 
   // Ctrl+Enter shall generate a keypress event with charCode=10 (LF).
   static const KeyEventTestData kTestCtrlEnter = {
-    base::VKEY_RETURN, true, false, false, false,
+    app::VKEY_RETURN, true, false, false, false,
     false, false, false, false, 5,
     { "D 17 0 true false false false",
       "D 13 0 true false false false",
@@ -473,7 +473,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
 
   // Press Escape to close the Find box and move the focus back to the web page.
   ASSERT_NO_FATAL_FAILURE(
-      SendKey(base::VKEY_ESCAPE, false, false, false, false));
+      SendKey(app::VKEY_ESCAPE, false, false, false, false));
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Press Ctrl+F with keydown suppressed shall not open the find box.
@@ -487,7 +487,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CtrlKeyEvents) {
 #elif defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CommandKeyEvents) {
   static const KeyEventTestData kTestCmdF = {
-    base::VKEY_F, false, false, false, true,
+    app::VKEY_F, false, false, false, true,
     false, false, false, false, 2,
     { "D 91 0 false false false true",
       "D 70 0 false false false true" }
@@ -495,7 +495,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CommandKeyEvents) {
 
   // On Mac we don't send key up events when command modifier is down.
   static const KeyEventTestData kTestCmdFSuppressKeyDown = {
-    base::VKEY_F, false, false, false, true,
+    app::VKEY_F, false, false, false, true,
     true, false, false, false, 3,
     { "D 91 0 false false false true",
       "D 70 0 false false false true",
@@ -518,7 +518,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, CommandKeyEvents) {
 
   // Press Escape to close the Find box and move the focus back to the web page.
   ASSERT_NO_FATAL_FAILURE(
-      SendKey(base::VKEY_ESCAPE, false, false, false, false));
+      SendKey(app::VKEY_ESCAPE, false, false, false, false));
   ASSERT_TRUE(IsViewFocused(VIEW_ID_TAB_CONTAINER_FOCUS_VIEW));
 
   // Press Cmd+F with keydown suppressed shall not open the find box.
@@ -531,7 +531,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
 #if defined(OS_MACOSX)
   // On Mac, access keys use ctrl+alt modifiers.
   static const KeyEventTestData kTestAccessA = {
-    base::VKEY_A, true, false, true, false,
+    app::VKEY_A, true, false, true, false,
     false, false, false, false, 6,
     { "D 17 0 true false false false",
       "D 18 0 true false true false",
@@ -542,7 +542,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
   };
 
   static const KeyEventTestData kTestAccessDSuppress = {
-    base::VKEY_D, true, false, true, false,
+    app::VKEY_D, true, false, true, false,
     true, true, true, false, 6,
     { "D 17 0 true false false false",
       "D 18 0 true false true false",
@@ -553,7 +553,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
   };
 
   static const KeyEventTestData kTestAccess1 = {
-    base::VKEY_1, true, false, true, false,
+    app::VKEY_1, true, false, true, false,
     false, false, false, false, 6,
     { "D 17 0 true false false false",
       "D 18 0 true false true false",
@@ -564,7 +564,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
   };
 #else
   static const KeyEventTestData kTestAccessA = {
-    base::VKEY_A, false, false, true, false,
+    app::VKEY_A, false, false, true, false,
     false, false, false, false, 4,
     { "D 18 0 false false true false",
       "D 65 0 false false true false",
@@ -573,14 +573,14 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
   };
 
   static const KeyEventTestData kTestAccessD = {
-    base::VKEY_D, false, false, true, false,
+    app::VKEY_D, false, false, true, false,
     false, false, false, false, 2,
     { "D 18 0 false false true false",
       "D 68 0 false false true false" }
   };
 
   static const KeyEventTestData kTestAccessDSuppress = {
-    base::VKEY_D, false, false, true, false,
+    app::VKEY_D, false, false, true, false,
     true, true, true, false, 4,
     { "D 18 0 false false true false",
       "D 68 0 false false true false",
@@ -589,7 +589,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, AccessKeys) {
   };
 
   static const KeyEventTestData kTestAccess1 = {
-    base::VKEY_1, false, false, true, false,
+    app::VKEY_1, false, false, true, false,
     false, false, false, false, 4,
     { "D 18 0 false false true false",
       "D 49 0 false false true false",
@@ -676,7 +676,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
 
 #if defined(OS_WIN) || defined(TOOLKIT_VIEWS)
   static const KeyEventTestData kTestCtrlT = {
-    base::VKEY_T, true, false, false, false,
+    app::VKEY_T, true, false, false, false,
     true, false, false, false, 1,
     { "D 17 0 true false false false" }
   };
@@ -695,11 +695,11 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
   // Reserved accelerators can't be suppressed.
   ASSERT_NO_FATAL_FAILURE(SuppressAllEvents(0, true));
   // Press Ctrl+W, which will close the tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_W, true, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_W, true, false, false, false));
   EXPECT_EQ(1, browser()->tab_count());
 #elif defined(OS_MACOSX)
   static const KeyEventTestData kTestCmdT = {
-    base::VKEY_T, false, false, false, true,
+    app::VKEY_T, false, false, false, true,
     true, false, false, false, 1,
     { "D 91 0 false false false true" }
   };
@@ -718,31 +718,31 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
   // Reserved accelerators can't be suppressed.
   ASSERT_NO_FATAL_FAILURE(SuppressAllEvents(0, true));
   // Press Cmd+W, which will close the tab.
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_W, false, false, false, true));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_W, false, false, false, true));
   EXPECT_EQ(1, browser()->tab_count());
 #elif defined(TOOLKIT_GTK)
   // Ctrl-[a-z] are not treated as reserved accelerators on GTK.
   static const KeyEventTestData kTestCtrlT = {
-    base::VKEY_T, true, false, false, false,
+    app::VKEY_T, true, false, false, false,
     false, false, false, false, 2,
     { "D 17 0 true false false false",
       "D 84 0 true false false false" }
   };
 
   static const KeyEventTestData kTestCtrlPageDown = {
-    base::VKEY_NEXT, true, false, false, false,
+    app::VKEY_NEXT, true, false, false, false,
     true, false, false, false, 1,
     { "D 17 0 true false false false" }
   };
 
   static const KeyEventTestData kTestCtrlTab = {
-    base::VKEY_TAB, true, false, false, false,
+    app::VKEY_TAB, true, false, false, false,
     true, false, false, false, 1,
     { "D 17 0 true false false false" }
   };
 
   static const KeyEventTestData kTestCtrlTBlocked = {
-    base::VKEY_T, true, false, false, false,
+    app::VKEY_T, true, false, false, false,
     true, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 84 0 true false false false",
@@ -751,7 +751,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
   };
 
   static const KeyEventTestData kTestCtrlWBlocked = {
-    base::VKEY_W, true, false, false, false,
+    app::VKEY_W, true, false, false, false,
     true, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 87 0 true false false false",
@@ -788,7 +788,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
 
   // Ctrl+F4 to close the tab.
   ASSERT_NO_FATAL_FAILURE(SuppressAllEvents(0, true));
-  ASSERT_NO_FATAL_FAILURE(SendKey(base::VKEY_F4, true, false, false, false));
+  ASSERT_NO_FATAL_FAILURE(SendKey(app::VKEY_F4, true, false, false, false));
   ASSERT_EQ(1, browser()->tab_count());
 #endif
 }
@@ -796,7 +796,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, MAYBE_ReservedAccelerators) {
 #if defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, EditorKeyBindings) {
   static const KeyEventTestData kTestCtrlA = {
-    base::VKEY_A, true, false, false, false,
+    app::VKEY_A, true, false, false, false,
     false, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 65 0 true false false false",
@@ -805,7 +805,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, EditorKeyBindings) {
   };
 
   static const KeyEventTestData kTestCtrlF = {
-    base::VKEY_F, true, false, false, false,
+    app::VKEY_F, true, false, false, false,
     false, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 70 0 true false false false",
@@ -814,7 +814,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, EditorKeyBindings) {
   };
 
   static const KeyEventTestData kTestCtrlK = {
-    base::VKEY_K, true, false, false, false,
+    app::VKEY_K, true, false, false, false,
     false, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 75 0 true false false false",
@@ -846,14 +846,14 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, EditorKeyBindings) {
 
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, PageUpDownKeys) {
   static const KeyEventTestData kTestPageUp = {
-    base::VKEY_PRIOR, false, false, false, false,
+    app::VKEY_PRIOR, false, false, false, false,
     false, false, false, false, 2,
     { "D 33 0 false false false false",
       "U 33 0 false false false false" }
   };
 
   static const KeyEventTestData kTestPageDown = {
-    base::VKEY_NEXT, false, false, false, false,
+    app::VKEY_NEXT, false, false, false, false,
     false, false, false, false, 2,
     { "D 34 0 false false false false",
       "U 34 0 false false false false" }
@@ -878,21 +878,21 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, PageUpDownKeys) {
 #if defined(OS_WIN) || defined(TOOLKIT_VIEWS)
 IN_PROC_BROWSER_TEST_F(BrowserKeyEventsTest, FocusMenuBarByAltKey) {
   static const KeyEventTestData kTestAltKey = {
-    base::VKEY_MENU, false, false, false, false,
+    app::VKEY_MENU, false, false, false, false,
     false, false, false, false, 2,
     { "D 18 0 false false true false",
       "U 18 0 false false true false" }
   };
 
   static const KeyEventTestData kTestAltKeySuppress = {
-    base::VKEY_MENU, false, false, false, false,
+    app::VKEY_MENU, false, false, false, false,
     true, false, false, false, 2,
     { "D 18 0 false false true false",
       "U 18 0 false false true false" }
   };
 
   static const KeyEventTestData kTestCtrlAltKey = {
-    base::VKEY_MENU, true, false, false, false,
+    app::VKEY_MENU, true, false, false, false,
     false, false, false, false, 4,
     { "D 17 0 true false false false",
       "D 18 0 true false true false",
diff --git a/chrome/browser/chromeos/login/existing_user_view.cc b/chrome/browser/chromeos/login/existing_user_view.cc
index 45c4176..eaadb11 100644
--- a/chrome/browser/chromeos/login/existing_user_view.cc
+++ b/chrome/browser/chromeos/login/existing_user_view.cc
@@ -45,7 +45,7 @@ class UserEntryTextfield : public views::Textfield {
 
   // Overridden from View:
   virtual bool OnKeyPressed(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == base::VKEY_TAB) {
+    if (e.GetKeyCode() == app::VKEY_TAB) {
       int index = controller_->user_index() + (e.IsShiftDown() ? -1 : 1);
       controller_->SelectUser(index);
       return true;
@@ -56,7 +56,7 @@ class UserEntryTextfield : public views::Textfield {
 
   // Overridden from views::Textfield:
   virtual bool SkipDefaultKeyEventProcessing(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == base::VKEY_TAB)
+    if (e.GetKeyCode() == app::VKEY_TAB)
       return true;
     else
       return views::Textfield::SkipDefaultKeyEventProcessing(e);
diff --git a/chrome/browser/chromeos/login/new_user_view.cc b/chrome/browser/chromeos/login/new_user_view.cc
index c3599e0..23211bc 100644
--- a/chrome/browser/chromeos/login/new_user_view.cc
+++ b/chrome/browser/chromeos/login/new_user_view.cc
@@ -10,11 +10,11 @@
 #include <algorithm>
 #include <vector>
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/command_line.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
@@ -83,8 +83,8 @@ NewUserView::NewUserView(Delegate* delegate,
       browse_without_signin_link_(NULL),
       languages_menubutton_(NULL),
       throbber_(NULL),
-      accel_focus_user_(views::Accelerator(base::VKEY_U, false, false, true)),
-      accel_focus_pass_(views::Accelerator(base::VKEY_P, false, false, true)),
+      accel_focus_user_(views::Accelerator(app::VKEY_U, false, false, true)),
+      accel_focus_pass_(views::Accelerator(app::VKEY_P, false, false, true)),
       delegate_(delegate),
       ALLOW_THIS_IN_INITIALIZER_LIST(focus_grabber_factory_(this)),
       focus_delayed_(false),
@@ -388,11 +388,11 @@ bool NewUserView::HandleKeystroke(views::Textfield* s,
   if (!CrosLibrary::Get()->EnsureLoaded() || login_in_process_)
     return false;
 
-  if (keystroke.GetKeyboardCode() == base::VKEY_RETURN) {
+  if (keystroke.GetKeyboardCode() == app::VKEY_RETURN) {
     Login();
     // Return true so that processing ends
     return true;
-  } else if (keystroke.GetKeyboardCode() == base::VKEY_LEFT) {
+  } else if (keystroke.GetKeyboardCode() == app::VKEY_LEFT) {
     if (s == username_field_ &&
         username_field_->text().empty() &&
         password_field_->text().empty()) {
diff --git a/chrome/browser/chromeos/login/password_changed_view.cc b/chrome/browser/chromeos/login/password_changed_view.cc
index ddb36ae..daa2909 100644
--- a/chrome/browser/chromeos/login/password_changed_view.cc
+++ b/chrome/browser/chromeos/login/password_changed_view.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/chromeos/login/password_changed_view.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "base/keyboard_codes.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/login/rounded_rect_painter.h"
 #include "grit/generated_resources.h"
@@ -162,7 +162,7 @@ void PasswordChangedView::ButtonPressed(Button* sender,
 
 bool PasswordChangedView::HandleKeystroke(views::Textfield* s,
     const views::Textfield::Keystroke& keystroke) {
-  if (keystroke.GetKeyboardCode() == base::VKEY_RETURN) {
+  if (keystroke.GetKeyboardCode() == app::VKEY_RETURN) {
     ExitDialog();
     return true;
   }
diff --git a/chrome/browser/chromeos/login/screen_lock_view.cc b/chrome/browser/chromeos/login/screen_lock_view.cc
index 3e19bc6..3906560 100644
--- a/chrome/browser/chromeos/login/screen_lock_view.cc
+++ b/chrome/browser/chromeos/login/screen_lock_view.cc
@@ -202,7 +202,7 @@ bool ScreenLockView::HandleKeystroke(
     views::Textfield* sender,
     const views::Textfield::Keystroke& keystroke) {
   screen_locker_->ClearErrors();
-  if (keystroke.GetKeyboardCode() == base::VKEY_RETURN) {
+  if (keystroke.GetKeyboardCode() == app::VKEY_RETURN) {
     screen_locker_->Authenticate(password_field_->text());
     return true;
   }
diff --git a/chrome/browser/chromeos/login/screen_locker.cc b/chrome/browser/chromeos/login/screen_locker.cc
index 9a2038c..85cc6bd 100644
--- a/chrome/browser/chromeos/login/screen_locker.cc
+++ b/chrome/browser/chromeos/login/screen_locker.cc
@@ -718,7 +718,7 @@ ScreenLocker::~ScreenLocker() {
     MessageLoopForUI::current()->RemoveObserver(input_event_observer_.get());
   if (locker_input_event_observer_.get()) {
     lock_widget_->GetFocusManager()->UnregisterAccelerator(
-        views::Accelerator(base::VKEY_ESCAPE, false, false, false), this);
+        views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
     MessageLoopForUI::current()->RemoveObserver(
         locker_input_event_observer_.get());
   }
@@ -750,7 +750,7 @@ void ScreenLocker::ScreenLockReady() {
   lock_widget_->GetRootView()->SetVisible(true);
   if (background_view_->ScreenSaverEnabled()) {
     lock_widget_->GetFocusManager()->RegisterAccelerator(
-        views::Accelerator(base::VKEY_ESCAPE, false, false, false), this);
+        views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
     locker_input_event_observer_.reset(new LockerInputEventObserver(this));
     MessageLoopForUI::current()->AddObserver(
         locker_input_event_observer_.get());
diff --git a/chrome/browser/chromeos/login/screen_locker_browsertest.cc b/chrome/browser/chromeos/login/screen_locker_browsertest.cc
index 5706e4d..f9fa9f4 100644
--- a/chrome/browser/chromeos/login/screen_locker_browsertest.cc
+++ b/chrome/browser/chromeos/login/screen_locker_browsertest.cc
@@ -246,7 +246,7 @@ IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestNoPasswordWithMouseClick) {
 
 void KeyPress(views::Widget* widget) {
   ui_controls::SendKeyPress(GTK_WINDOW(widget->GetNativeView()),
-                            base::VKEY_SPACE, false, false, false, false);
+                            app::VKEY_SPACE, false, false, false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestNoPasswordWithKeyPress) {
diff --git a/chrome/browser/chromeos/login/update_view.cc b/chrome/browser/chromeos/login/update_view.cc
index b99f4af..e99d13d 100644
--- a/chrome/browser/chromeos/login/update_view.cc
+++ b/chrome/browser/chromeos/login/update_view.cc
@@ -56,7 +56,7 @@ const SkColor kManualRebootLabelColor = 0xFFAA0000;
 namespace chromeos {
 
 UpdateView::UpdateView(chromeos::ScreenObserver* observer)
-    : escape_accelerator_(base::VKEY_ESCAPE, false, false, false),
+    : escape_accelerator_(app::VKEY_ESCAPE, false, false, false),
       installing_updates_label_(NULL),
       reboot_label_(NULL),
       manual_reboot_label_(NULL),
@@ -199,7 +199,7 @@ void UpdateView::Layout() {
 bool UpdateView::AcceleratorPressed(const views::Accelerator& a) {
 #if !defined(OFFICIAL_BUILD)
   RemoveAccelerator(escape_accelerator_);
-  if (a.GetKeyCode() == base::VKEY_ESCAPE) {
+  if (a.GetKeyCode() == app::VKEY_ESCAPE) {
     if (controller_ != NULL) {
       controller_->CancelUpdate();
     }
diff --git a/chrome/browser/chromeos/login/user_controller.cc b/chrome/browser/chromeos/login/user_controller.cc
index 80cb08d..8f60fc3 100644
--- a/chrome/browser/chromeos/login/user_controller.cc
+++ b/chrome/browser/chromeos/login/user_controller.cc
@@ -212,13 +212,13 @@ void UserController::ButtonPressed(views::Button* sender,
 bool UserController::HandleKeystroke(
     views::Textfield* sender,
     const views::Textfield::Keystroke& keystroke) {
-  if (keystroke.GetKeyboardCode() == base::VKEY_RETURN) {
+  if (keystroke.GetKeyboardCode() == app::VKEY_RETURN) {
     Login();
     return true;
-  } else if (keystroke.GetKeyboardCode() == base::VKEY_LEFT) {
+  } else if (keystroke.GetKeyboardCode() == app::VKEY_LEFT) {
     SelectUser(user_index() - 1);
     return true;
-  } else if (keystroke.GetKeyboardCode() == base::VKEY_RIGHT) {
+  } else if (keystroke.GetKeyboardCode() == app::VKEY_RIGHT) {
     SelectUser(user_index() + 1);
     return true;
   }
diff --git a/chrome/browser/chromeos/login/wizard_accessibility_helper.h b/chrome/browser/chromeos/login/wizard_accessibility_helper.h
index fa411ca..5f4d370 100644
--- a/chrome/browser/chromeos/login/wizard_accessibility_helper.h
+++ b/chrome/browser/chromeos/login/wizard_accessibility_helper.h
@@ -6,7 +6,7 @@
 #define CHROME_BROWSER_CHROMEOS_LOGIN_WIZARD_ACCESSIBILITY_HELPER_H_
 #pragma once
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "chrome/browser/chromeos/login/wizard_accessibility_handler.h"
@@ -34,7 +34,7 @@ class WizardAccessibilityHelper {
   void MaybeEnableAccessibility(views::View* view_tree, Profile* profile);
 
   // Keyboard accelerator key to enable accessibility.
-  static const base::KeyboardCode accelerator = base::VKEY_Z;
+  static const app::KeyboardCode accelerator = app::VKEY_Z;
 
  private:
   friend struct DefaultSingletonTraits<WizardAccessibilityHelper>;
diff --git a/chrome/browser/chromeos/login/wizard_controller.cc b/chrome/browser/chromeos/login/wizard_controller.cc
index 82faecd..d8f40b1 100644
--- a/chrome/browser/chromeos/login/wizard_controller.cc
+++ b/chrome/browser/chromeos/login/wizard_controller.cc
@@ -86,19 +86,19 @@ class ContentView : public views::View {
         window_y_(window_y),
         screen_w_(screen_w),
         screen_h_(screen_h),
-        accel_account_screen_(views::Accelerator(base::VKEY_A,
+        accel_account_screen_(views::Accelerator(app::VKEY_A,
                                                  false, true, true)),
-        accel_login_screen_(views::Accelerator(base::VKEY_L,
+        accel_login_screen_(views::Accelerator(app::VKEY_L,
                                                false, true, true)),
-        accel_network_screen_(views::Accelerator(base::VKEY_N,
+        accel_network_screen_(views::Accelerator(app::VKEY_N,
                                                  false, true, true)),
-        accel_update_screen_(views::Accelerator(base::VKEY_U,
+        accel_update_screen_(views::Accelerator(app::VKEY_U,
                                                 false, true, true)),
-        accel_image_screen_(views::Accelerator(base::VKEY_I,
+        accel_image_screen_(views::Accelerator(app::VKEY_I,
                                                false, true, true)),
-        accel_eula_screen_(views::Accelerator(base::VKEY_E,
+        accel_eula_screen_(views::Accelerator(app::VKEY_E,
                                               false, true, true)),
-        accel_register_screen_(views::Accelerator(base::VKEY_R,
+        accel_register_screen_(views::Accelerator(app::VKEY_R,
                                                   false, true, true)),
         accel_enable_accessibility_(views::Accelerator(
             WizardAccessibilityHelper::accelerator, false, true, true)) {
diff --git a/chrome/browser/chromeos/login/wizard_controller_browsertest.cc b/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
index 1fa0261..67d4fde 100644
--- a/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
+++ b/chrome/browser/chromeos/login/wizard_controller_browsertest.cc
@@ -203,12 +203,12 @@ IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, Accelerators) {
 
   views::FocusManager* focus_manager =
       controller()->contents()->GetFocusManager();
-  views::Accelerator accel_account_screen(base::VKEY_A, false, true, true);
-  views::Accelerator accel_login_screen(base::VKEY_L, false, true, true);
-  views::Accelerator accel_network_screen(base::VKEY_N, false, true, true);
-  views::Accelerator accel_update_screen(base::VKEY_U, false, true, true);
-  views::Accelerator accel_image_screen(base::VKEY_I, false, true, true);
-  views::Accelerator accel_eula_screen(base::VKEY_E, false, true, true);
+  views::Accelerator accel_account_screen(app::VKEY_A, false, true, true);
+  views::Accelerator accel_login_screen(app::VKEY_L, false, true, true);
+  views::Accelerator accel_network_screen(app::VKEY_N, false, true, true);
+  views::Accelerator accel_update_screen(app::VKEY_U, false, true, true);
+  views::Accelerator accel_image_screen(app::VKEY_I, false, true, true);
+  views::Accelerator accel_eula_screen(app::VKEY_E, false, true, true);
 
   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
   EXPECT_CALL(*mock_account_screen_, Show()).Times(1);
diff --git a/chrome/browser/cocoa/html_dialog_window_controller.mm b/chrome/browser/cocoa/html_dialog_window_controller.mm
index 0db46c7..87691fb 100644
--- a/chrome/browser/cocoa/html_dialog_window_controller.mm
+++ b/chrome/browser/cocoa/html_dialog_window_controller.mm
@@ -4,7 +4,7 @@
 
 #import "chrome/browser/cocoa/html_dialog_window_controller.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
@@ -194,8 +194,8 @@ void HtmlDialogWindowDelegateBridge::HandleKeyboardEvent(
   // TODO(thakis): It would be nice to get cancel: to work somehow.
   // Bug: http://code.google.com/p/chromium/issues/detail?id=32828 .
   if (event.type == NativeWebKeyboardEvent::RawKeyDown &&
-      ((event.windowsKeyCode == base::VKEY_ESCAPE) ||
-       (event.windowsKeyCode == base::VKEY_OEM_PERIOD &&
+      ((event.windowsKeyCode == app::VKEY_ESCAPE) ||
+       (event.windowsKeyCode == app::VKEY_OEM_PERIOD &&
         event.modifiers == NativeWebKeyboardEvent::MetaKey))) {
     [controller_ close];
     return;
diff --git a/chrome/browser/extensions/extension_host.cc b/chrome/browser/extensions/extension_host.cc
index 39e3cd9..bca2f6f 100644
--- a/chrome/browser/extensions/extension_host.cc
+++ b/chrome/browser/extensions/extension_host.cc
@@ -6,9 +6,9 @@
 
 #include <list>
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
@@ -627,7 +627,7 @@ bool ExtensionHost::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                            bool* is_keyboard_shortcut) {
   if (extension_host_type_ == ViewType::EXTENSION_POPUP &&
       event.type == NativeWebKeyboardEvent::RawKeyDown &&
-      event.windowsKeyCode == base::VKEY_ESCAPE) {
+      event.windowsKeyCode == app::VKEY_ESCAPE) {
     DCHECK(is_keyboard_shortcut != NULL);
     *is_keyboard_shortcut = true;
   }
@@ -637,7 +637,7 @@ bool ExtensionHost::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
 void ExtensionHost::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
   if (extension_host_type_ == ViewType::EXTENSION_POPUP) {
     if (event.type == NativeWebKeyboardEvent::RawKeyDown &&
-        event.windowsKeyCode == base::VKEY_ESCAPE) {
+        event.windowsKeyCode == app::VKEY_ESCAPE) {
       NotificationService::current()->Notify(
           NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE,
           Source<Profile>(profile_),
diff --git a/chrome/browser/extensions/extension_input_api.cc b/chrome/browser/extensions/extension_input_api.cc
index 40c4bc0..c4ce3f6 100644
--- a/chrome/browser/extensions/extension_input_api.cc
+++ b/chrome/browser/extensions/extension_input_api.cc
@@ -6,8 +6,8 @@
 
 #include <string>
 
+#include "app/keyboard_code_conversion.h"
 #include "base/values.h"
-#include "base/keyboard_code_conversion.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
@@ -84,8 +84,8 @@ bool SendKeyboardEventInputFunction::RunImpl() {
 
   std::string identifier;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(kKeyIdentifier, &identifier));
-  base::KeyboardCode code = base::KeyCodeFromKeyIdentifier(identifier);
-  if (code == base::VKEY_UNKNOWN) {
+  app::KeyboardCode code = app::KeyCodeFromKeyIdentifier(identifier);
+  if (code == app::VKEY_UNKNOWN) {
     error_ = kUnknownOrUnsupportedKeyIdentiferError;
     return false;
   }
diff --git a/chrome/browser/external_tab_container_win.cc b/chrome/browser/external_tab_container_win.cc
index d3a7684..f645793 100644
--- a/chrome/browser/external_tab_container_win.cc
+++ b/chrome/browser/external_tab_container_win.cc
@@ -918,7 +918,7 @@ void ExternalTabContainer::LoadAccelerators() {
     bool ctrl_down = (accelerators[i].fVirt & FCONTROL) == FCONTROL;
     bool shift_down = (accelerators[i].fVirt & FSHIFT) == FSHIFT;
     views::Accelerator accelerator(
-        static_cast<base::KeyboardCode>(accelerators[i].key),
+        static_cast<app::KeyboardCode>(accelerators[i].key),
         shift_down, ctrl_down, alt_down);
     accelerator_table_[accelerator] = accelerators[i].cmd;
 
diff --git a/chrome/browser/find_bar_host_browsertest.cc b/chrome/browser/find_bar_host_browsertest.cc
index d68e35d..e5f7068 100644
--- a/chrome/browser/find_bar_host_browsertest.cc
+++ b/chrome/browser/find_bar_host_browsertest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ -721,7 +721,7 @@ IN_PROC_BROWSER_TEST_F(FindInPageControllerTest,
           browser()->window()->GetNativeHandle());
 
   // See where Escape is registered.
-  views::Accelerator escape(base::VKEY_ESCAPE, false, false, false);
+  views::Accelerator escape(app::VKEY_ESCAPE, false, false, false);
   views::AcceleratorTarget* old_target =
       focus_manager->GetCurrentTargetForAccelerator(escape);
   EXPECT_TRUE(old_target != NULL);
diff --git a/chrome/browser/gtk/browser_window_gtk.cc b/chrome/browser/gtk/browser_window_gtk.cc
index 1cef421..da1a13d 100644
--- a/chrome/browser/gtk/browser_window_gtk.cc
+++ b/chrome/browser/gtk/browser_window_gtk.cc
@@ -9,10 +9,10 @@
 #include <string>
 
 #include "app/gtk_util.h"
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "base/base_paths.h"
 #include "base/command_line.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ -299,8 +299,8 @@ bool ShouldExecuteReservedCommandImmediately(
   // Keys like Ctrl+w, Ctrl+n, etc. should always be sent to the renderer first,
   // otherwise some web apps or the Emacs key bindings may not work correctly.
   int vkey = event.windowsKeyCode;
-  if ((vkey >= base::VKEY_0 && vkey <= base::VKEY_9) ||
-      (vkey >= base::VKEY_A && vkey <= base::VKEY_Z))
+  if ((vkey >= app::VKEY_0 && vkey <= app::VKEY_9) ||
+      (vkey >= app::VKEY_A && vkey <= app::VKEY_Z))
     return false;
 
   // All other reserved accelerators should be processed immediately.
diff --git a/chrome/browser/renderer_host/render_widget_host.cc b/chrome/browser/renderer_host/render_widget_host.cc
index 30766ea..5c5ee42 100644
--- a/chrome/browser/renderer_host/render_widget_host.cc
+++ b/chrome/browser/renderer_host/render_widget_host.cc
@@ -4,10 +4,10 @@
 
 #include "chrome/browser/renderer_host/render_widget_host.h"
 
+#include "app/keyboard_codes.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/histogram.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/renderer_host/backing_store.h"
@@ -468,8 +468,8 @@ void RenderWidgetHost::ForwardKeyboardEvent(
     return;
 
   if (key_event.type == WebKeyboardEvent::Char &&
-      (key_event.windowsKeyCode == base::VKEY_RETURN ||
-       key_event.windowsKeyCode == base::VKEY_SPACE)) {
+      (key_event.windowsKeyCode == app::VKEY_RETURN ||
+       key_event.windowsKeyCode == app::VKEY_SPACE)) {
     OnUserGesture();
   }
 
diff --git a/chrome/browser/renderer_host/render_widget_host_unittest.cc b/chrome/browser/renderer_host/render_widget_host_unittest.cc
index 1fe03ed..1c5bb17 100644
--- a/chrome/browser/renderer_host/render_widget_host_unittest.cc
+++ b/chrome/browser/renderer_host/render_widget_host_unittest.cc
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
@@ -264,7 +264,7 @@ class RenderWidgetHostTest : public testing::Test {
   void SimulateKeyboardEvent(WebInputEvent::Type type) {
     NativeWebKeyboardEvent key_event;
     key_event.type = type;
-    key_event.windowsKeyCode = base::VKEY_L;  // non-null made up value.
+    key_event.windowsKeyCode = app::VKEY_L;  // non-null made up value.
     host_->ForwardKeyboardEvent(key_event);
   }
 
diff --git a/chrome/browser/views/accelerator_table_gtk.cc b/chrome/browser/views/accelerator_table_gtk.cc
index 1841ac6..ff6b87d 100644
--- a/chrome/browser/views/accelerator_table_gtk.cc
+++ b/chrome/browser/views/accelerator_table_gtk.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/views/accelerator_table_gtk.h"
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "chrome/app/chrome_dll_resource.h"
 
 namespace browser {
@@ -14,135 +14,135 @@ namespace browser {
 // the Windows accelerators in ../../app/chrome_dll.rc.
 const AcceleratorMapping kAcceleratorMap[] = {
   // Keycode                   Shift  Ctrl   Alt    Command ID
-  { base::VKEY_A,              true,  true,  false, IDC_AUTOFILL_DEFAULT },
-  { base::VKEY_LEFT,           false, false, true,  IDC_BACK },
-  { base::VKEY_BACK,           false, false, false, IDC_BACK },
+  { app::VKEY_A,              true,  true,  false, IDC_AUTOFILL_DEFAULT },
+  { app::VKEY_LEFT,           false, false, true,  IDC_BACK },
+  { app::VKEY_BACK,           false, false, false, IDC_BACK },
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F1,             false, false, false, IDC_BACK },
+  { app::VKEY_F1,             false, false, false, IDC_BACK },
 #endif
-  { base::VKEY_D,              false, true,  false, IDC_BOOKMARK_PAGE },
-  { base::VKEY_D,              true,  true,  false, IDC_BOOKMARK_ALL_TABS },
-  { base::VKEY_DELETE,         true,  true,  false, IDC_CLEAR_BROWSING_DATA },
+  { app::VKEY_D,              false, true,  false, IDC_BOOKMARK_PAGE },
+  { app::VKEY_D,              true,  true,  false, IDC_BOOKMARK_ALL_TABS },
+  { app::VKEY_DELETE,         true,  true,  false, IDC_CLEAR_BROWSING_DATA },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F4,             false, true,  false, IDC_CLOSE_TAB },
+  { app::VKEY_F4,             false, true,  false, IDC_CLOSE_TAB },
 #endif
-  { base::VKEY_W,              false, true,  false, IDC_CLOSE_TAB },
-  { base::VKEY_W,              true,  true,  false, IDC_CLOSE_WINDOW },
+  { app::VKEY_W,              false, true,  false, IDC_CLOSE_TAB },
+  { app::VKEY_W,              true,  true,  false, IDC_CLOSE_WINDOW },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F4,             false, false, true,  IDC_CLOSE_WINDOW },
+  { app::VKEY_F4,             false, false, true,  IDC_CLOSE_WINDOW },
 #endif
-  { base::VKEY_Q,              true,  true,  false, IDC_EXIT },
-  { base::VKEY_F,              false, true,  false, IDC_FIND },
-  { base::VKEY_G,              false, true,  false, IDC_FIND_NEXT },
+  { app::VKEY_Q,              true,  true,  false, IDC_EXIT },
+  { app::VKEY_F,              false, true,  false, IDC_FIND },
+  { app::VKEY_G,              false, true,  false, IDC_FIND_NEXT },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F3,             false, false, false, IDC_FIND_NEXT },
+  { app::VKEY_F3,             false, false, false, IDC_FIND_NEXT },
 #endif
-  { base::VKEY_G,              true,  true,  false, IDC_FIND_PREVIOUS },
+  { app::VKEY_G,              true,  true,  false, IDC_FIND_PREVIOUS },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F3,             true,  false, false, IDC_FIND_PREVIOUS },
+  { app::VKEY_F3,             true,  false, false, IDC_FIND_PREVIOUS },
 #endif
 #if defined(OS_CHROMEOS)
-  { base::VKEY_S,              true,  false, true,  IDC_FOCUS_CHROMEOS_STATUS },
+  { app::VKEY_S,              true,  false, true,  IDC_FOCUS_CHROMEOS_STATUS },
 #endif
-  { base::VKEY_D,              false, false, true,  IDC_FOCUS_LOCATION },
-  { base::VKEY_L,              false, true,  false, IDC_FOCUS_LOCATION },
+  { app::VKEY_D,              false, false, true,  IDC_FOCUS_LOCATION },
+  { app::VKEY_L,              false, true,  false, IDC_FOCUS_LOCATION },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F10,            false, false, false, IDC_FOCUS_MENU_BAR },
+  { app::VKEY_F10,            false, false, false, IDC_FOCUS_MENU_BAR },
 #endif
-  { base::VKEY_MENU,           false, false, false, IDC_FOCUS_MENU_BAR },
+  { app::VKEY_MENU,           false, false, false, IDC_FOCUS_MENU_BAR },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F6,             false, false, false, IDC_FOCUS_NEXT_PANE },
+  { app::VKEY_F6,             false, false, false, IDC_FOCUS_NEXT_PANE },
 #endif
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F2,             false, true,  false, IDC_FOCUS_NEXT_PANE },
+  { app::VKEY_F2,             false, true,  false, IDC_FOCUS_NEXT_PANE },
 #endif
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F6,             true,  false, false, IDC_FOCUS_PREVIOUS_PANE },
+  { app::VKEY_F6,             true,  false, false, IDC_FOCUS_PREVIOUS_PANE },
 #endif
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F1,             false, true,  false, IDC_FOCUS_PREVIOUS_PANE },
-#endif
-  { base::VKEY_K,              false, true,  false, IDC_FOCUS_SEARCH },
-  { base::VKEY_E,              false, true,  false, IDC_FOCUS_SEARCH },
-  { base::VKEY_BROWSER_SEARCH, false, false, false, IDC_FOCUS_SEARCH },
-  { base::VKEY_T,              true,  false, true,  IDC_FOCUS_TOOLBAR },
-  { base::VKEY_B,              true,  false, true,  IDC_FOCUS_BOOKMARKS },
-  { base::VKEY_RIGHT,          false, false, true,  IDC_FORWARD },
-  { base::VKEY_BACK,           true,  false, false, IDC_FORWARD },
+  { app::VKEY_F1,             false, true,  false, IDC_FOCUS_PREVIOUS_PANE },
+#endif
+  { app::VKEY_K,              false, true,  false, IDC_FOCUS_SEARCH },
+  { app::VKEY_E,              false, true,  false, IDC_FOCUS_SEARCH },
+  { app::VKEY_BROWSER_SEARCH, false, false, false, IDC_FOCUS_SEARCH },
+  { app::VKEY_T,              true,  false, true,  IDC_FOCUS_TOOLBAR },
+  { app::VKEY_B,              true,  false, true,  IDC_FOCUS_BOOKMARKS },
+  { app::VKEY_RIGHT,          false, false, true,  IDC_FORWARD },
+  { app::VKEY_BACK,           true,  false, false, IDC_FORWARD },
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F2,             false, false, false, IDC_FORWARD },
+  { app::VKEY_F2,             false, false, false, IDC_FORWARD },
 #endif
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F11,            false, false, false, IDC_FULLSCREEN },
+  { app::VKEY_F11,            false, false, false, IDC_FULLSCREEN },
 #endif
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F4,             false, false, false, IDC_FULLSCREEN },
+  { app::VKEY_F4,             false, false, false, IDC_FULLSCREEN },
 #endif
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F1,             false, false, false, IDC_HELP_PAGE },
-#endif
-  { base::VKEY_I,              true,  true,  false, IDC_DEV_TOOLS },
-  { base::VKEY_J,              true,  true,  false, IDC_DEV_TOOLS_CONSOLE },
-  { base::VKEY_C,              true,  true,  false, IDC_DEV_TOOLS_INSPECT },
-  { base::VKEY_N,              true,  true,  false, IDC_NEW_INCOGNITO_WINDOW },
-  { base::VKEY_T,              false, true,  false, IDC_NEW_TAB },
-  { base::VKEY_N,              false, true,  false, IDC_NEW_WINDOW },
-  { base::VKEY_O,              false, true,  false, IDC_OPEN_FILE },
-  { base::VKEY_P,              false, true,  false, IDC_PRINT},
-  { base::VKEY_R,              false, true,  false, IDC_RELOAD },
-  { base::VKEY_R,              true,  true,  false, IDC_RELOAD_IGNORING_CACHE },
+  { app::VKEY_F1,             false, false, false, IDC_HELP_PAGE },
+#endif
+  { app::VKEY_I,              true,  true,  false, IDC_DEV_TOOLS },
+  { app::VKEY_J,              true,  true,  false, IDC_DEV_TOOLS_CONSOLE },
+  { app::VKEY_C,              true,  true,  false, IDC_DEV_TOOLS_INSPECT },
+  { app::VKEY_N,              true,  true,  false, IDC_NEW_INCOGNITO_WINDOW },
+  { app::VKEY_T,              false, true,  false, IDC_NEW_TAB },
+  { app::VKEY_N,              false, true,  false, IDC_NEW_WINDOW },
+  { app::VKEY_O,              false, true,  false, IDC_OPEN_FILE },
+  { app::VKEY_P,              false, true,  false, IDC_PRINT},
+  { app::VKEY_R,              false, true,  false, IDC_RELOAD },
+  { app::VKEY_R,              true,  true,  false, IDC_RELOAD_IGNORING_CACHE },
 #if !defined(OS_CHROMEOS)
-  { base::VKEY_F5,             false, false, false, IDC_RELOAD },
-  { base::VKEY_F5,             false, true,  false, IDC_RELOAD_IGNORING_CACHE },
-  { base::VKEY_F5,             true,  false, false, IDC_RELOAD_IGNORING_CACHE },
+  { app::VKEY_F5,             false, false, false, IDC_RELOAD },
+  { app::VKEY_F5,             false, true,  false, IDC_RELOAD_IGNORING_CACHE },
+  { app::VKEY_F5,             true,  false, false, IDC_RELOAD_IGNORING_CACHE },
 #endif
-  { base::VKEY_HOME,           false, false, true,  IDC_HOME },
-  { base::VKEY_T,              true,  true,  false, IDC_RESTORE_TAB },
-  { base::VKEY_S,              false, true,  false, IDC_SAVE_PAGE },
+  { app::VKEY_HOME,           false, false, true,  IDC_HOME },
+  { app::VKEY_T,              true,  true,  false, IDC_RESTORE_TAB },
+  { app::VKEY_S,              false, true,  false, IDC_SAVE_PAGE },
 #if defined(OS_CHROMEOS)
-  { base::VKEY_LWIN,           false, false, false, IDC_SEARCH },
-#endif
-  { base::VKEY_9,              false, true,  false, IDC_SELECT_LAST_TAB },
-  { base::VKEY_NUMPAD9,        false, true,  false, IDC_SELECT_LAST_TAB },
-  { base::VKEY_TAB,            false, true,  false, IDC_SELECT_NEXT_TAB },
-  { base::VKEY_NEXT,           false, true,  false, IDC_SELECT_NEXT_TAB },
-  { base::VKEY_TAB,            true,  true,  false, IDC_SELECT_PREVIOUS_TAB },
-  { base::VKEY_PRIOR,          false, true,  false, IDC_SELECT_PREVIOUS_TAB },
-  { base::VKEY_1,              false, true,  false, IDC_SELECT_TAB_0 },
-  { base::VKEY_NUMPAD1,        false, true,  false, IDC_SELECT_TAB_0 },
-  { base::VKEY_2,              false, true,  false, IDC_SELECT_TAB_1 },
-  { base::VKEY_NUMPAD2,        false, true,  false, IDC_SELECT_TAB_1 },
-  { base::VKEY_3,              false, true,  false, IDC_SELECT_TAB_2 },
-  { base::VKEY_NUMPAD3,        false, true,  false, IDC_SELECT_TAB_2 },
-  { base::VKEY_4,              false, true,  false, IDC_SELECT_TAB_3 },
-  { base::VKEY_NUMPAD4,        false, true,  false, IDC_SELECT_TAB_3 },
-  { base::VKEY_5,              false, true,  false, IDC_SELECT_TAB_4 },
-  { base::VKEY_NUMPAD5,        false, true,  false, IDC_SELECT_TAB_4 },
-  { base::VKEY_6,              false, true,  false, IDC_SELECT_TAB_5 },
-  { base::VKEY_NUMPAD6,        false, true,  false, IDC_SELECT_TAB_5 },
-  { base::VKEY_7,              false, true,  false, IDC_SELECT_TAB_6 },
-  { base::VKEY_NUMPAD7,        false, true,  false, IDC_SELECT_TAB_6 },
-  { base::VKEY_8,              false, true,  false, IDC_SELECT_TAB_7 },
-  { base::VKEY_NUMPAD8,        false, true,  false, IDC_SELECT_TAB_7 },
-  { base::VKEY_B,              true,  true,  false, IDC_SHOW_BOOKMARK_BAR },
-  { base::VKEY_J,              false, true,  false, IDC_SHOW_DOWNLOADS },
-  { base::VKEY_H,              false, true,  false, IDC_SHOW_HISTORY },
-  { base::VKEY_F,              false, false, true,  IDC_SHOW_APP_MENU},
-  { base::VKEY_E,              false, false, true,  IDC_SHOW_APP_MENU},
-  { base::VKEY_ESCAPE,         false, false, false, IDC_STOP },
+  { app::VKEY_LWIN,           false, false, false, IDC_SEARCH },
+#endif
+  { app::VKEY_9,              false, true,  false, IDC_SELECT_LAST_TAB },
+  { app::VKEY_NUMPAD9,        false, true,  false, IDC_SELECT_LAST_TAB },
+  { app::VKEY_TAB,            false, true,  false, IDC_SELECT_NEXT_TAB },
+  { app::VKEY_NEXT,           false, true,  false, IDC_SELECT_NEXT_TAB },
+  { app::VKEY_TAB,            true,  true,  false, IDC_SELECT_PREVIOUS_TAB },
+  { app::VKEY_PRIOR,          false, true,  false, IDC_SELECT_PREVIOUS_TAB },
+  { app::VKEY_1,              false, true,  false, IDC_SELECT_TAB_0 },
+  { app::VKEY_NUMPAD1,        false, true,  false, IDC_SELECT_TAB_0 },
+  { app::VKEY_2,              false, true,  false, IDC_SELECT_TAB_1 },
+  { app::VKEY_NUMPAD2,        false, true,  false, IDC_SELECT_TAB_1 },
+  { app::VKEY_3,              false, true,  false, IDC_SELECT_TAB_2 },
+  { app::VKEY_NUMPAD3,        false, true,  false, IDC_SELECT_TAB_2 },
+  { app::VKEY_4,              false, true,  false, IDC_SELECT_TAB_3 },
+  { app::VKEY_NUMPAD4,        false, true,  false, IDC_SELECT_TAB_3 },
+  { app::VKEY_5,              false, true,  false, IDC_SELECT_TAB_4 },
+  { app::VKEY_NUMPAD5,        false, true,  false, IDC_SELECT_TAB_4 },
+  { app::VKEY_6,              false, true,  false, IDC_SELECT_TAB_5 },
+  { app::VKEY_NUMPAD6,        false, true,  false, IDC_SELECT_TAB_5 },
+  { app::VKEY_7,              false, true,  false, IDC_SELECT_TAB_6 },
+  { app::VKEY_NUMPAD7,        false, true,  false, IDC_SELECT_TAB_6 },
+  { app::VKEY_8,              false, true,  false, IDC_SELECT_TAB_7 },
+  { app::VKEY_NUMPAD8,        false, true,  false, IDC_SELECT_TAB_7 },
+  { app::VKEY_B,              true,  true,  false, IDC_SHOW_BOOKMARK_BAR },
+  { app::VKEY_J,              false, true,  false, IDC_SHOW_DOWNLOADS },
+  { app::VKEY_H,              false, true,  false, IDC_SHOW_HISTORY },
+  { app::VKEY_F,              false, false, true,  IDC_SHOW_APP_MENU},
+  { app::VKEY_E,              false, false, true,  IDC_SHOW_APP_MENU},
+  { app::VKEY_ESCAPE,         false, false, false, IDC_STOP },
 #if defined(OS_CHROMEOS)
-  { base::VKEY_F5,             false, false, false, IDC_SYSTEM_OPTIONS },
-#endif
-  { base::VKEY_ESCAPE,         true,  false, false, IDC_TASK_MANAGER },
-  { base::VKEY_U,              false, true,  false, IDC_VIEW_SOURCE },
-  { base::VKEY_OEM_MINUS,      false, true,  false, IDC_ZOOM_MINUS },
-  { base::VKEY_OEM_MINUS,      true,  true,  false, IDC_ZOOM_MINUS },
-  { base::VKEY_SUBTRACT,       false, true,  false, IDC_ZOOM_MINUS },
-  { base::VKEY_0,              false, true,  false, IDC_ZOOM_NORMAL },
-  { base::VKEY_NUMPAD0,        false, true,  false, IDC_ZOOM_NORMAL },
-  { base::VKEY_OEM_PLUS,       false, true,  false, IDC_ZOOM_PLUS },
-  { base::VKEY_OEM_PLUS,       true,  true,  false, IDC_ZOOM_PLUS },
-  { base::VKEY_ADD,            false, true,  false, IDC_ZOOM_PLUS },
+  { app::VKEY_F5,             false, false, false, IDC_SYSTEM_OPTIONS },
+#endif
+  { app::VKEY_ESCAPE,         true,  false, false, IDC_TASK_MANAGER },
+  { app::VKEY_U,              false, true,  false, IDC_VIEW_SOURCE },
+  { app::VKEY_OEM_MINUS,      false, true,  false, IDC_ZOOM_MINUS },
+  { app::VKEY_OEM_MINUS,      true,  true,  false, IDC_ZOOM_MINUS },
+  { app::VKEY_SUBTRACT,       false, true,  false, IDC_ZOOM_MINUS },
+  { app::VKEY_0,              false, true,  false, IDC_ZOOM_NORMAL },
+  { app::VKEY_NUMPAD0,        false, true,  false, IDC_ZOOM_NORMAL },
+  { app::VKEY_OEM_PLUS,       false, true,  false, IDC_ZOOM_PLUS },
+  { app::VKEY_OEM_PLUS,       true,  true,  false, IDC_ZOOM_PLUS },
+  { app::VKEY_ADD,            false, true,  false, IDC_ZOOM_PLUS },
 };
 
 const size_t kAcceleratorMapLength = arraysize(kAcceleratorMap);
diff --git a/chrome/browser/views/accelerator_table_gtk.h b/chrome/browser/views/accelerator_table_gtk.h
index 46abbcc..bbab634 100644
--- a/chrome/browser/views/accelerator_table_gtk.h
+++ b/chrome/browser/views/accelerator_table_gtk.h
@@ -8,14 +8,14 @@
 
 #include <stdio.h>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
 // This contains the list of accelerators for the Linux toolkit_view
 // implementation.
 namespace browser {
 
   struct AcceleratorMapping {
-    base::KeyboardCode keycode;
+    app::KeyboardCode keycode;
     bool shift_pressed;
     bool ctrl_pressed;
     bool alt_pressed;
diff --git a/chrome/browser/views/accessible_toolbar_view.cc b/chrome/browser/views/accessible_toolbar_view.cc
index a06a342..7a73087 100644
--- a/chrome/browser/views/accessible_toolbar_view.cc
+++ b/chrome/browser/views/accessible_toolbar_view.cc
@@ -18,11 +18,11 @@ AccessibleToolbarView::AccessibleToolbarView()
     : toolbar_has_focus_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       focus_manager_(NULL),
-      home_key_(base::VKEY_HOME, false, false, false),
-      end_key_(base::VKEY_END, false, false, false),
-      escape_key_(base::VKEY_ESCAPE, false, false, false),
-      left_key_(base::VKEY_LEFT, false, false, false),
-      right_key_(base::VKEY_RIGHT, false, false, false),
+      home_key_(app::VKEY_HOME, false, false, false),
+      end_key_(app::VKEY_END, false, false, false),
+      escape_key_(app::VKEY_ESCAPE, false, false, false),
+      left_key_(app::VKEY_LEFT, false, false, false),
+      right_key_(app::VKEY_RIGHT, false, false, false),
       last_focused_view_storage_id_(-1) {
   focus_search_.reset(new views::FocusSearch(this, true, true));
 }
@@ -148,27 +148,27 @@ bool AccessibleToolbarView::AcceleratorPressed(
   views::View* focused_view = focus_manager_->GetFocusedView();
   if ((focused_view->GetClassName() == LocationBarView::kViewClassName ||
        focused_view->GetClassName() == views::NativeViewHost::kViewClassName) &&
-      (accelerator.GetKeyCode() == base::VKEY_LEFT ||
-       accelerator.GetKeyCode() == base::VKEY_RIGHT)) {
+      (accelerator.GetKeyCode() == app::VKEY_LEFT ||
+       accelerator.GetKeyCode() == app::VKEY_RIGHT)) {
     return false;
   }
 
   switch (accelerator.GetKeyCode()) {
-    case base::VKEY_ESCAPE:
+    case app::VKEY_ESCAPE:
       RemoveToolbarFocus();
       RestoreLastFocusedView();
       return true;
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       focus_manager_->AdvanceFocus(true);
       return true;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       focus_manager_->AdvanceFocus(false);
       return true;
-    case base::VKEY_HOME:
+    case app::VKEY_HOME:
       focus_manager_->SetFocusedViewWithReason(
           GetFirstFocusableChild(), views::FocusManager::kReasonFocusTraversal);
       return true;
-    case base::VKEY_END:
+    case app::VKEY_END:
       focus_manager_->SetFocusedViewWithReason(
           GetLastFocusableChild(), views::FocusManager::kReasonFocusTraversal);
       return true;
diff --git a/chrome/browser/views/bookmark_bar_view_test.cc b/chrome/browser/views/bookmark_bar_view_test.cc
index d3884dd..9b7b512 100644
--- a/chrome/browser/views/bookmark_bar_view_test.cc
+++ b/chrome/browser/views/bookmark_bar_view_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/automation/ui_controls.h"
@@ -873,7 +873,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send a down event, which should select the first item.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_DOWN, false, false, false, false,
+        NULL, app::VKEY_DOWN, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step3));
   }
 
@@ -886,7 +886,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send a key down event, which should select the next item.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_DOWN, false, false, false, false,
+        NULL, app::VKEY_DOWN, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step4));
   }
 
@@ -899,7 +899,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send a right arrow to force the menu to open.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_RIGHT, false, false, false, false,
+        NULL, app::VKEY_RIGHT, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step5));
   }
 
@@ -915,7 +915,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send a left arrow to close the submenu.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_LEFT, false, false, false, false,
+        NULL, app::VKEY_LEFT, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step6));
   }
 
@@ -930,7 +930,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send a down arrow to wrap back to f1a
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_DOWN, false, false, false, false,
+        NULL, app::VKEY_DOWN, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step7));
   }
 
@@ -943,7 +943,7 @@ class BookmarkBarViewTest10 : public BookmarkBarViewEventTestBase {
 
     // Send enter, which should select the item.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_RETURN, false, false, false, false,
+        NULL, app::VKEY_RETURN, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest10::Step8));
   }
 
@@ -998,7 +998,7 @@ class BookmarkBarViewTest11 : public BookmarkBarViewEventTestBase {
   void Step3() {
     // Send escape so that the context menu hides.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_ESCAPE, false, false, false, false,
+        NULL, app::VKEY_ESCAPE, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest11::Step4));
   }
 
@@ -1087,7 +1087,7 @@ class BookmarkBarViewTest12 : public BookmarkBarViewEventTestBase {
 
   void Step4() {
     // Press tab to give focus to the cancel button.
-    ui_controls::SendKeyPress(NULL, base::VKEY_TAB, false, false, false, false);
+    ui_controls::SendKeyPress(NULL, app::VKEY_TAB, false, false, false, false);
 
     // For some reason return isn't processed correctly unless we delay.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
@@ -1097,7 +1097,7 @@ class BookmarkBarViewTest12 : public BookmarkBarViewEventTestBase {
   void Step5() {
     // And press enter so that the cancel button is selected.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_RETURN, false, false, false, false,
+        NULL, app::VKEY_RETURN, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest12::Step6));
   }
 
@@ -1226,7 +1226,7 @@ class BookmarkBarViewTest14 : public BookmarkBarViewEventTestBase {
 
     // Send escape so that the context menu hides.
     ui_controls::SendKeyPressNotifyWhenDone(
-        NULL, base::VKEY_ESCAPE, false, false, false, false,
+        NULL, app::VKEY_ESCAPE, false, false, false, false,
         CreateEventTask(this, &BookmarkBarViewTest14::Step3));
   }
 
diff --git a/chrome/browser/views/bookmark_bubble_view.cc b/chrome/browser/views/bookmark_bubble_view.cc
index 96065eb..c13f53f 100644
--- a/chrome/browser/views/bookmark_bubble_view.cc
+++ b/chrome/browser/views/bookmark_bubble_view.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/views/bookmark_bubble_view.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "base/keyboard_codes.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ -129,7 +129,7 @@ void BookmarkBubbleView::DidChangeBounds(const gfx::Rect& previous,
 void BookmarkBubbleView::BubbleShown() {
   DCHECK(GetWidget());
   GetFocusManager()->RegisterAccelerator(
-      views::Accelerator(base::VKEY_RETURN, false, false, false), this);
+      views::Accelerator(app::VKEY_RETURN, false, false, false), this);
 
   title_tf_->RequestFocus();
   title_tf_->SelectAll();
@@ -137,7 +137,7 @@ void BookmarkBubbleView::BubbleShown() {
 
 bool BookmarkBubbleView::AcceleratorPressed(
     const views::Accelerator& accelerator) {
-  if (accelerator.GetKeyCode() != base::VKEY_RETURN)
+  if (accelerator.GetKeyCode() != app::VKEY_RETURN)
     return false;
 
   if (edit_button_->HasFocus())
diff --git a/chrome/browser/views/browser_keyboard_accessibility_test_win.cc b/chrome/browser/views/browser_keyboard_accessibility_test_win.cc
index f5b942f..1218367 100644
--- a/chrome/browser/views/browser_keyboard_accessibility_test_win.cc
+++ b/chrome/browser/views/browser_keyboard_accessibility_test_win.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/views/chrome_views_delegate.h"
 #include "chrome/browser/views/frame/browser_view.h"
@@ -119,7 +119,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyboardAccessibility,
     // TODO(phajdan.jr): remove logging after fixing http://crbug.com/50663.
     LOG(ERROR) << "Sending TAB key event...";
     ui_controls::SendKeyPressNotifyWhenDone(current_view_native_window(),
-                                            base::VKEY_TAB,
+                                            app::VKEY_TAB,
                                             true, false, false, false,
                                             new MessageLoop::QuitTask());
     set_waiting(true);
@@ -153,7 +153,7 @@ IN_PROC_BROWSER_TEST_F(BrowserKeyboardAccessibility,
                        DISABLED_TabInToolbar) {
   gfx::NativeWindow native_window = browser()->window()->GetNativeHandle();
   ui_controls::SendKeyPressNotifyWhenDone(native_window,
-                                          base::VKEY_T,
+                                          app::VKEY_T,
                                           false, true, true, false,
                                           new MessageLoop::QuitTask());
   set_waiting(true);
@@ -197,7 +197,7 @@ void BrowserKeyboardAccessibility::TabCycler(gfx::NativeWindow hwnd,
   do {
     // TODO(phajdan.jr): remove logging after fixing http://crbug.com/50663.
     LOG(ERROR) << "Sending TAB key event.";
-    ui_controls::SendKeyPressNotifyWhenDone(hwnd, base::VKEY_TAB,
+    ui_controls::SendKeyPressNotifyWhenDone(hwnd, app::VKEY_TAB,
         false, !forward_tab, false, false, new MessageLoop::QuitTask());
     set_waiting(true);
     ui_test_utils::RunMessageLoop();
diff --git a/chrome/browser/views/dropdown_bar_host.cc b/chrome/browser/views/dropdown_bar_host.cc
index f756cb2..e55365b 100644
--- a/chrome/browser/views/dropdown_bar_host.cc
+++ b/chrome/browser/views/dropdown_bar_host.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/views/dropdown_bar_host.h"
 
+#include "app/keyboard_codes.h"
 #include "app/slide_animation.h"
-#include "base/keyboard_codes.h"
 #include "base/scoped_handle.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
@@ -297,14 +297,14 @@ void DropdownBarHost::UpdateWindowEdges(const gfx::Rect& new_pos) {
 
 void DropdownBarHost::RegisterAccelerators() {
   DCHECK(!esc_accel_target_registered_);
-  views::Accelerator escape(base::VKEY_ESCAPE, false, false, false);
+  views::Accelerator escape(app::VKEY_ESCAPE, false, false, false);
   focus_manager_->RegisterAccelerator(escape, this);
   esc_accel_target_registered_ = true;
 }
 
 void DropdownBarHost::UnregisterAccelerators() {
   DCHECK(esc_accel_target_registered_);
-  views::Accelerator escape(base::VKEY_ESCAPE, false, false, false);
+  views::Accelerator escape(app::VKEY_ESCAPE, false, false, false);
   focus_manager_->UnregisterAccelerator(escape, this);
   esc_accel_target_registered_ = false;
 }
diff --git a/chrome/browser/views/extensions/extension_view.cc b/chrome/browser/views/extensions/extension_view.cc
index 4e7f1ae..062bc00 100644
--- a/chrome/browser/views/extensions/extension_view.cc
+++ b/chrome/browser/views/extensions/extension_view.cc
@@ -173,7 +173,7 @@ void ExtensionView::PreferredSizeChanged() {
 bool ExtensionView::SkipDefaultKeyEventProcessing(const views::KeyEvent& e) {
   // Let the tab key event be processed by the renderer (instead of moving the
   // focus to the next focusable view).
-  return (e.GetKeyCode() == base::VKEY_TAB);
+  return (e.GetKeyCode() == app::VKEY_TAB);
 }
 
 void ExtensionView::HandleMouseMove() {
diff --git a/chrome/browser/views/find_bar_host.cc b/chrome/browser/views/find_bar_host.cc
index 21dcf8b..3926e70 100644
--- a/chrome/browser/views/find_bar_host.cc
+++ b/chrome/browser/views/find_bar_host.cc
@@ -4,7 +4,7 @@
 
 #include "chrome/browser/views/find_bar_host.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/find_bar_controller.h"
@@ -48,13 +48,13 @@ bool FindBarHost::MaybeForwardKeystrokeToWebpage(
   }
 
   switch (key_stroke.GetKeyboardCode()) {
-    case base::VKEY_DOWN:
-    case base::VKEY_UP:
-    case base::VKEY_PRIOR:
-    case base::VKEY_NEXT:
+    case app::VKEY_DOWN:
+    case app::VKEY_UP:
+    case app::VKEY_PRIOR:
+    case app::VKEY_NEXT:
       break;
-    case base::VKEY_HOME:
-    case base::VKEY_END:
+    case app::VKEY_HOME:
+    case app::VKEY_END:
       if (key_stroke.IsControlHeld())
         break;
     // Fall through.
@@ -161,11 +161,11 @@ FindBarTesting* FindBarHost::GetFindBarTesting() {
 // FindBarWin, views::AcceleratorTarget implementation:
 
 bool FindBarHost::AcceleratorPressed(const views::Accelerator& accelerator) {
-  base::KeyboardCode key = accelerator.GetKeyCode();
-  if (key == base::VKEY_RETURN && accelerator.IsCtrlDown()) {
+  app::KeyboardCode key = accelerator.GetKeyCode();
+  if (key == app::VKEY_RETURN && accelerator.IsCtrlDown()) {
     // Ctrl+Enter closes the Find session and navigates any link that is active.
     find_bar_controller_->EndFindSession(FindBarController::kActivateSelection);
-  } else if (key == base::VKEY_ESCAPE) {
+  } else if (key == app::VKEY_ESCAPE) {
     // This will end the Find session and hide the window, causing it to loose
     // focus and in the process unregister us as the handler for the Escape
     // accelerator through the FocusWillChange event.
@@ -277,13 +277,13 @@ void FindBarHost::RegisterAccelerators() {
   DropdownBarHost::RegisterAccelerators();
 
   // Register for Ctrl+Return.
-  views::Accelerator escape(base::VKEY_RETURN, false, true, false);
+  views::Accelerator escape(app::VKEY_RETURN, false, true, false);
   focus_manager()->RegisterAccelerator(escape, this);
 }
 
 void FindBarHost::UnregisterAccelerators() {
   // Unregister Ctrl+Return.
-  views::Accelerator escape(base::VKEY_RETURN, false, true, false);
+  views::Accelerator escape(app::VKEY_RETURN, false, true, false);
   focus_manager()->UnregisterAccelerator(escape, this);
 
   DropdownBarHost::UnregisterAccelerators();
diff --git a/chrome/browser/views/find_bar_host_interactive_uitest.cc b/chrome/browser/views/find_bar_host_interactive_uitest.cc
index 69d7284..baf9cf44 100644
--- a/chrome/browser/views/find_bar_host_interactive_uitest.cc
+++ b/chrome/browser/views/find_bar_host_interactive_uitest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ -121,7 +121,7 @@ IN_PROC_BROWSER_TEST_F(FindInPageTest, CrashEscHandlers) {
 
   // This used to crash until bug 1303709 was fixed.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      browser()->window()->GetNativeHandle(), base::VKEY_ESCAPE,
+      browser()->window()->GetNativeHandle(), app::VKEY_ESCAPE,
       false, false, false, false));
 }
 
@@ -187,21 +187,21 @@ IN_PROC_BROWSER_TEST_F(FindInPageTest, PrepopulateRespectBlank) {
 
   // Search for "a".
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_A, false, false, false, false));  // No modifiers
+      window, app::VKEY_A, false, false, false, false));  // No modifiers
 
   // We should find "a" here.
   EXPECT_EQ(ASCIIToUTF16("a"), GetFindBarText());
 
   // Delete "a".
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_BACK, false, false, false, false));  // No modifiers.
+      window, app::VKEY_BACK, false, false, false, false));  // No modifiers.
 
   // Validate we have cleared the text.
   EXPECT_EQ(string16(), GetFindBarText());
 
   // Close the Find box.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_ESCAPE, false, false, false, false));  // No modifiers.
+      window, app::VKEY_ESCAPE, false, false, false, false));  // No modifiers.
 
   // Show the Find bar.
   browser()->GetFindBarController()->Show();
@@ -212,11 +212,11 @@ IN_PROC_BROWSER_TEST_F(FindInPageTest, PrepopulateRespectBlank) {
 
   // Close the Find box.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_ESCAPE, false, false, false, false));  // No modifiers.
+      window, app::VKEY_ESCAPE, false, false, false, false));  // No modifiers.
 
   // Press F3 to trigger FindNext.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
-      window, base::VKEY_F3, false, false, false, false));  // No modifiers.
+      window, app::VKEY_F3, false, false, false, false));  // No modifiers.
 
   // After the Find box has been reopened, it should still have no prepopulate
   // value.
diff --git a/chrome/browser/views/find_bar_view.cc b/chrome/browser/views/find_bar_view.cc
index 0007d9c..7132553 100644
--- a/chrome/browser/views/find_bar_view.cc
+++ b/chrome/browser/views/find_bar_view.cc
@@ -475,7 +475,7 @@ bool FindBarView::HandleKeystroke(views::Textfield* sender,
   if (find_bar_host()->MaybeForwardKeystrokeToWebpage(key))
     return true;  // Handled, we are done!
 
-  if (key.GetKeyboardCode() == base::VKEY_RETURN) {
+  if (key.GetKeyboardCode() == app::VKEY_RETURN) {
     // Pressing Return/Enter starts the search (unless text box is empty).
     string16 find_string = find_text_->text();
     if (!find_string.empty()) {
diff --git a/chrome/browser/views/frame/browser_view.cc b/chrome/browser/views/frame/browser_view.cc
index 819fb75..28d187a 100644
--- a/chrome/browser/views/frame/browser_view.cc
+++ b/chrome/browser/views/frame/browser_view.cc
@@ -688,13 +688,13 @@ bool BrowserView::GetAccelerator(int cmd_id, menus::Accelerator* accelerator) {
   // anywhere so we need to check for them explicitly here.
   switch (cmd_id) {
     case IDC_CUT:
-      *accelerator = views::Accelerator(base::VKEY_X, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_X, false, true, false);
       return true;
     case IDC_COPY:
-      *accelerator = views::Accelerator(base::VKEY_C, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_C, false, true, false);
       return true;
     case IDC_PASTE:
-      *accelerator = views::Accelerator(base::VKEY_V, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_V, false, true, false);
       return true;
   }
   // Else, we retrieve the accelerator information from the accelerator table.
@@ -1293,7 +1293,7 @@ bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
 #if defined(OS_WIN)
   // As Alt+F4 is the close-app keyboard shortcut, it needs processing
   // immediately.
-  if (event.windowsKeyCode == base::VKEY_F4 &&
+  if (event.windowsKeyCode == app::VKEY_F4 &&
       event.modifiers == NativeWebKeyboardEvent::AltKey) {
     DefWindowProc(event.os_event.hwnd, event.os_event.message,
                   event.os_event.wParam, event.os_event.lParam);
@@ -1305,7 +1305,7 @@ bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
   DCHECK(focus_manager);
 
   views::Accelerator accelerator(
-      static_cast<base::KeyboardCode>(event.windowsKeyCode),
+      static_cast<app::KeyboardCode>(event.windowsKeyCode),
       (event.modifiers & NativeWebKeyboardEvent::ShiftKey) ==
           NativeWebKeyboardEvent::ShiftKey,
       (event.modifiers & NativeWebKeyboardEvent::ControlKey) ==
@@ -1371,34 +1371,34 @@ void BrowserView::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
 // manager to do that.
 #if !defined(OS_MACOSX)
 void BrowserView::Cut() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_X,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_X,
                             true, false, false, false);
 }
 
 void BrowserView::Copy() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_C,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_C,
                             true, false, false, false);
 }
 
 void BrowserView::Paste() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_V,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_V,
                             true, false, false, false);
 }
 #else
 // Mac versions.  Not tested by antyhing yet;
 // don't assume written == works.
 void BrowserView::Cut() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_X,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_X,
                             false, false, false, true);
 }
 
 void BrowserView::Copy() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_C,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_C,
                             false, false, false, true);
 }
 
 void BrowserView::Paste() {
-  ui_controls::SendKeyPress(GetNativeHandle(), base::VKEY_V,
+  ui_controls::SendKeyPress(GetNativeHandle(), app::VKEY_V,
                             false, false, false, true);
 }
 #endif
@@ -2304,7 +2304,7 @@ void BrowserView::LoadAccelerators() {
     bool ctrl_down = (accelerators[i].fVirt & FCONTROL) == FCONTROL;
     bool shift_down = (accelerators[i].fVirt & FSHIFT) == FSHIFT;
     views::Accelerator accelerator(
-        static_cast<base::KeyboardCode>(accelerators[i].key),
+        static_cast<app::KeyboardCode>(accelerators[i].key),
         shift_down, ctrl_down, alt_down);
     accelerator_table_[accelerator] = accelerators[i].cmd;
 
diff --git a/chrome/browser/views/fullscreen_exit_bubble.cc b/chrome/browser/views/fullscreen_exit_bubble.cc
index e44b4d7..4777f51 100644
--- a/chrome/browser/views/fullscreen_exit_bubble.cc
+++ b/chrome/browser/views/fullscreen_exit_bubble.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/views/fullscreen_exit_bubble.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "base/keyboard_codes.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "gfx/canvas_skia.h"
 #include "grit/generated_resources.h"
@@ -142,7 +142,7 @@ FullscreenExitBubble::FullscreenExitBubble(
   size_animation_->Reset(1);
 
   // Create the contents view.
-  views::Accelerator accelerator(base::VKEY_UNKNOWN, false, false, false);
+  views::Accelerator accelerator(app::VKEY_UNKNOWN, false, false, false);
   bool got_accelerator = frame->GetAccelerator(IDC_FULLSCREEN, &accelerator);
   DCHECK(got_accelerator);
   view_ = new FullscreenExitView(this, accelerator.GetShortcutText());
diff --git a/chrome/browser/views/html_dialog_view.cc b/chrome/browser/views/html_dialog_view.cc
index 3fd6157..d2f4c04 100644
--- a/chrome/browser/views/html_dialog_view.cc
+++ b/chrome/browser/views/html_dialog_view.cc
@@ -4,7 +4,7 @@
 
 #include "chrome/browser/views/html_dialog_view.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/native_web_keyboard_event.h"
@@ -55,7 +55,7 @@ gfx::Size HtmlDialogView::GetPreferredSize() {
 
 bool HtmlDialogView::AcceleratorPressed(const views::Accelerator& accelerator) {
   // Pressing ESC closes the dialog.
-  DCHECK_EQ(base::VKEY_ESCAPE, accelerator.GetKeyCode());
+  DCHECK_EQ(app::VKEY_ESCAPE, accelerator.GetKeyCode());
   OnDialogClosed(std::string());
   return true;
 }
@@ -201,7 +201,7 @@ void HtmlDialogView::InitDialog() {
                                                   this);
 
   // Pressing the ESC key will close the dialog.
-  AddAccelerator(views::Accelerator(base::VKEY_ESCAPE, false, false, false));
+  AddAccelerator(views::Accelerator(app::VKEY_ESCAPE, false, false, false));
 
   DOMView::LoadURL(GetDialogContentURL());
 }
diff --git a/chrome/browser/views/info_bubble.cc b/chrome/browser/views/info_bubble.cc
index 48b7626..3ee1317 100644
--- a/chrome/browser/views/info_bubble.cc
+++ b/chrome/browser/views/info_bubble.cc
@@ -4,7 +4,7 @@
 
 #include "chrome/browser/views/info_bubble.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/notification_service.h"
 #include "gfx/canvas_skia.h"
@@ -426,7 +426,7 @@ void InfoBubble::Init(views::Widget* parent,
 
   // Register the Escape accelerator for closing.
   GetFocusManager()->RegisterAccelerator(
-      views::Accelerator(base::VKEY_ESCAPE, false, false, false), this);
+      views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
 
   // Done creating the bubble.
   NotificationService::current()->Notify(NotificationType::INFO_BUBBLE_CREATED,
@@ -491,7 +491,7 @@ void InfoBubble::DoClose(bool closed_by_escape) {
     return;
 
   GetFocusManager()->UnregisterAccelerator(
-      views::Accelerator(base::VKEY_ESCAPE, false, false, false), this);
+      views::Accelerator(app::VKEY_ESCAPE, false, false, false), this);
   if (delegate_)
     delegate_->InfoBubbleClosing(this, closed_by_escape);
   show_status_ = kClosed;
diff --git a/chrome/browser/views/jsmessage_box_dialog.cc b/chrome/browser/views/jsmessage_box_dialog.cc
index 5d8049a..f51116b 100644
--- a/chrome/browser/views/jsmessage_box_dialog.cc
+++ b/chrome/browser/views/jsmessage_box_dialog.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/views/jsmessage_box_dialog.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/message_box_flags.h"
-#include "base/keyboard_codes.h"
 #include "chrome/browser/app_modal_dialog.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "grit/generated_resources.h"
@@ -25,7 +25,7 @@ JavaScriptMessageBoxDialog::JavaScriptMessageBoxDialog(
   DCHECK(message_box_view_);
 
   message_box_view_->AddAccelerator(
-      views::Accelerator(base::VKEY_C, false, true, false));
+      views::Accelerator(app::VKEY_C, false, true, false));
   if (display_suppress_checkbox) {
     message_box_view_->SetCheckBoxLabel(
         l10n_util::GetString(IDS_JAVASCRIPT_MESSAGEBOX_SUPPRESS_OPTION));
diff --git a/chrome/browser/views/keyword_editor_view.cc b/chrome/browser/views/keyword_editor_view.cc
index 5815843..b3b4974 100644
--- a/chrome/browser/views/keyword_editor_view.cc
+++ b/chrome/browser/views/keyword_editor_view.cc
@@ -169,7 +169,7 @@ void KeywordEditorView::Init() {
       this, l10n_util::GetString(IDS_SEARCH_ENGINES_EDITOR_NEW_BUTTON));
   add_button_->SetEnabled(controller_->loaded());
   add_button_->AddAccelerator(
-      views::Accelerator(base::VKEY_A, false, false, true));
+      views::Accelerator(app::VKEY_A, false, false, true));
   add_button_->SetAccessibleKeyboardShortcut(L"A");
 
   edit_button_ = new views::NativeButton(
@@ -180,7 +180,7 @@ void KeywordEditorView::Init() {
       this, l10n_util::GetString(IDS_SEARCH_ENGINES_EDITOR_REMOVE_BUTTON));
   remove_button_->SetEnabled(false);
   remove_button_->AddAccelerator(
-      views::Accelerator(base::VKEY_R, false, false, true));
+      views::Accelerator(app::VKEY_R, false, false, true));
   remove_button_->SetAccessibleKeyboardShortcut(L"R");
 
   make_default_button_ = new views::NativeButton(
diff --git a/chrome/browser/views/location_bar/location_bar_view.cc b/chrome/browser/views/location_bar/location_bar_view.cc
index 97b9f2a..7b0ad1d 100644
--- a/chrome/browser/views/location_bar/location_bar_view.cc
+++ b/chrome/browser/views/location_bar/location_bar_view.cc
@@ -942,7 +942,7 @@ bool LocationBarView::SkipDefaultKeyEventProcessing(const views::KeyEvent& e) {
   // it can be shared between Windows and Linux.
   // For now, we just override back-space and tab keys, as back-space is the
   // accelerator for back navigation and tab key is used by some input methods.
-  if (e.GetKeyCode() == base::VKEY_BACK ||
+  if (e.GetKeyCode() == app::VKEY_BACK ||
       views::FocusManager::IsTabTraversalKeyEvent(e))
     return true;
   return false;
diff --git a/chrome/browser/views/location_bar/page_action_image_view.cc b/chrome/browser/views/location_bar/page_action_image_view.cc
index c2d72e3..058100c 100644
--- a/chrome/browser/views/location_bar/page_action_image_view.cc
+++ b/chrome/browser/views/location_bar/page_action_image_view.cc
@@ -137,8 +137,8 @@ void PageActionImageView::OnMouseReleased(const views::MouseEvent& event,
 }
 
 bool PageActionImageView::OnKeyPressed(const views::KeyEvent& e) {
-  if (e.GetKeyCode() == base::VKEY_SPACE ||
-      e.GetKeyCode() == base::VKEY_RETURN) {
+  if (e.GetKeyCode() == app::VKEY_SPACE ||
+      e.GetKeyCode() == app::VKEY_RETURN) {
     ExecuteAction(1, false);
     return true;
   }
diff --git a/chrome/browser/views/location_bar/star_view.cc b/chrome/browser/views/location_bar/star_view.cc
index 06bb843..9b4f2c5 100644
--- a/chrome/browser/views/location_bar/star_view.cc
+++ b/chrome/browser/views/location_bar/star_view.cc
@@ -59,8 +59,8 @@ void StarView::OnMouseReleased(const views::MouseEvent& event, bool canceled) {
 }
 
 bool StarView::OnKeyPressed(const views::KeyEvent& e) {
-  if (e.GetKeyCode() == base::VKEY_SPACE ||
-      e.GetKeyCode() == base::VKEY_RETURN) {
+  if (e.GetKeyCode() == app::VKEY_SPACE ||
+      e.GetKeyCode() == app::VKEY_RETURN) {
     command_updater_->ExecuteCommand(IDC_BOOKMARK_PAGE);
     return true;
   }
diff --git a/chrome/browser/views/options/cookies_view.cc b/chrome/browser/views/options/cookies_view.cc
index 48de80f..2bba860 100644
--- a/chrome/browser/views/options/cookies_view.cc
+++ b/chrome/browser/views/options/cookies_view.cc
@@ -145,9 +145,9 @@ void CookiesView::ContentsChanged(views::Textfield* sender,
 
 bool CookiesView::HandleKeystroke(views::Textfield* sender,
                                   const views::Textfield::Keystroke& key) {
-  if (key.GetKeyboardCode() == base::VKEY_ESCAPE) {
+  if (key.GetKeyboardCode() == app::VKEY_ESCAPE) {
     ResetSearchQuery();
-  } else if (key.GetKeyboardCode() == base::VKEY_RETURN) {
+  } else if (key.GetKeyboardCode() == app::VKEY_RETURN) {
     search_update_factory_.RevokeAll();
     UpdateSearchResults();
   }
@@ -235,8 +235,8 @@ void CookiesView::OnTreeViewSelectionChanged(views::TreeView* tree_view) {
   }
 }
 
-void CookiesView::OnTreeViewKeyDown(base::KeyboardCode keycode) {
-  if (keycode == base::VKEY_DELETE)
+void CookiesView::OnTreeViewKeyDown(app::KeyboardCode keycode) {
+  if (keycode == app::VKEY_DELETE)
     cookies_tree_->RemoveSelectedItems();
 }
 
diff --git a/chrome/browser/views/options/cookies_view.h b/chrome/browser/views/options/cookies_view.h
index ce51933..121affd 100644
--- a/chrome/browser/views/options/cookies_view.h
+++ b/chrome/browser/views/options/cookies_view.h
@@ -71,7 +71,7 @@ class CookiesView : public CookiesTreeModel::Observer,
   virtual void OnTreeViewSelectionChanged(views::TreeView* tree_view);
 
   // views::TreeViewController implementation.
-  virtual void OnTreeViewKeyDown(base::KeyboardCode keycode);
+  virtual void OnTreeViewKeyDown(app::KeyboardCode keycode);
 
   // views::Textfield::Controller implementation.
   virtual void ContentsChanged(views::Textfield* sender,
diff --git a/chrome/browser/views/tab_contents/render_view_context_menu_views.cc b/chrome/browser/views/tab_contents/render_view_context_menu_views.cc
index f2092c5..8efb30b 100644
--- a/chrome/browser/views/tab_contents/render_view_context_menu_views.cc
+++ b/chrome/browser/views/tab_contents/render_view_context_menu_views.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/views/tab_contents/render_view_context_menu_views.h"
 
+#include "app/keyboard_codes.h"
 #include "base/compiler_specific.h"
-#include "base/keyboard_codes.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/profile.h"
 #include "grit/generated_resources.h"
@@ -68,28 +68,28 @@ bool RenderViewContextMenuViews::GetAcceleratorForCommandId(
   // that Ctrl+C, Ctrl+V, Ctrl+X, Ctrl-A, etc do what they normally do.
   switch (command_id) {
     case IDC_CONTENT_CONTEXT_UNDO:
-      *accel = views::Accelerator(base::VKEY_Z, false, true, false);
+      *accel = views::Accelerator(app::VKEY_Z, false, true, false);
       return true;
 
     case IDC_CONTENT_CONTEXT_REDO:
       // TODO(jcampan): should it be Ctrl-Y?
-      *accel = views::Accelerator(base::VKEY_Z, true, true, false);
+      *accel = views::Accelerator(app::VKEY_Z, true, true, false);
       return true;
 
     case IDC_CONTENT_CONTEXT_CUT:
-      *accel = views::Accelerator(base::VKEY_X, false, true, false);
+      *accel = views::Accelerator(app::VKEY_X, false, true, false);
       return true;
 
     case IDC_CONTENT_CONTEXT_COPY:
-      *accel = views::Accelerator(base::VKEY_C, false, true, false);
+      *accel = views::Accelerator(app::VKEY_C, false, true, false);
       return true;
 
     case IDC_CONTENT_CONTEXT_PASTE:
-      *accel = views::Accelerator(base::VKEY_V, false, true, false);
+      *accel = views::Accelerator(app::VKEY_V, false, true, false);
       return true;
 
     case IDC_CONTENT_CONTEXT_SELECTALL:
-      *accel = views::Accelerator(base::VKEY_A, false, true, false);
+      *accel = views::Accelerator(app::VKEY_A, false, true, false);
       return true;
 
     default:
diff --git a/chrome/browser/views/task_manager_view.cc b/chrome/browser/views/task_manager_view.cc
index d4bdbce..9a3e923 100644
--- a/chrome/browser/views/task_manager_view.cc
+++ b/chrome/browser/views/task_manager_view.cc
@@ -222,7 +222,7 @@ class TaskManagerView : public views::View,
   // views::TableViewObserver implementation.
   virtual void OnSelectionChanged();
   virtual void OnDoubleClick();
-  virtual void OnKeyDown(base::KeyboardCode keycode);
+  virtual void OnKeyDown(app::KeyboardCode keycode);
 
   // views::LinkController implementation.
   virtual void LinkActivated(views::Link* source, int event_flags);
@@ -372,7 +372,7 @@ void TaskManagerView::Init() {
   }
   kill_button_ = new views::NativeButton(
       this, l10n_util::GetString(IDS_TASK_MANAGER_KILL));
-  kill_button_->AddAccelerator(views::Accelerator(base::VKEY_E,
+  kill_button_->AddAccelerator(views::Accelerator(app::VKEY_E,
                                                   false, false, false));
   kill_button_->SetAccessibleKeyboardShortcut(L"E");
   about_memory_link_ = new views::Link(
@@ -588,8 +588,8 @@ void TaskManagerView::OnDoubleClick() {
   ActivateFocusedTab();
 }
 
-void TaskManagerView::OnKeyDown(base::KeyboardCode keycode) {
-  if (keycode == base::VKEY_RETURN)
+void TaskManagerView::OnKeyDown(app::KeyboardCode keycode) {
+  if (keycode == app::VKEY_RETURN)
     ActivateFocusedTab();
 }
 
diff --git a/chrome/browser/views/toolbar_view.cc b/chrome/browser/views/toolbar_view.cc
index baa4fdd..ccdc7e2 100644
--- a/chrome/browser/views/toolbar_view.cc
+++ b/chrome/browser/views/toolbar_view.cc
@@ -353,13 +353,13 @@ bool ToolbarView::GetAcceleratorForCommandId(int command_id,
   // TODO(cpu) Bug 1109102. Query WebKit land for the actual bindings.
   switch (command_id) {
     case IDC_CUT:
-      *accelerator = views::Accelerator(base::VKEY_X, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_X, false, true, false);
       return true;
     case IDC_COPY:
-      *accelerator = views::Accelerator(base::VKEY_C, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_C, false, true, false);
       return true;
     case IDC_PASTE:
-      *accelerator = views::Accelerator(base::VKEY_V, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_V, false, true, false);
       return true;
   }
   // Else, we retrieve the accelerator information from the frame.
diff --git a/chrome/browser/views/unhandled_keyboard_event_handler.cc b/chrome/browser/views/unhandled_keyboard_event_handler.cc
index cc29354..9da60ee2 100644
--- a/chrome/browser/views/unhandled_keyboard_event_handler.cc
+++ b/chrome/browser/views/unhandled_keyboard_event_handler.cc
@@ -38,7 +38,7 @@ void UnhandledKeyboardEventHandler::HandleKeyboardEvent(
 
   if (event.type == WebKit::WebInputEvent::RawKeyDown) {
     views::Accelerator accelerator(
-        static_cast<base::KeyboardCode>(event.windowsKeyCode),
+        static_cast<app::KeyboardCode>(event.windowsKeyCode),
         (event.modifiers & NativeWebKeyboardEvent::ShiftKey) ==
             NativeWebKeyboardEvent::ShiftKey,
         (event.modifiers & NativeWebKeyboardEvent::ControlKey) ==
diff --git a/chrome/browser/views/url_picker.cc b/chrome/browser/views/url_picker.cc
index 3b9ac40..4051e63 100644
--- a/chrome/browser/views/url_picker.cc
+++ b/chrome/browser/views/url_picker.cc
@@ -4,10 +4,10 @@
 
 #include "chrome/browser/views/url_picker.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/table_model.h"
-#include "base/keyboard_codes.h"
 #include "base/stl_util-inl.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
@@ -113,7 +113,7 @@ UrlPicker::UrlPicker(UrlPickerDelegate* delegate,
 
   layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
-  AddAccelerator(views::Accelerator(base::VKEY_RETURN, false, false, false));
+  AddAccelerator(views::Accelerator(app::VKEY_RETURN, false, false, false));
 }
 
 UrlPicker::~UrlPicker() {
diff --git a/chrome/renderer/password_autocomplete_manager.cc b/chrome/renderer/password_autocomplete_manager.cc
index b74d357..c460db4 100644
--- a/chrome/renderer/password_autocomplete_manager.cc
+++ b/chrome/renderer/password_autocomplete_manager.cc
@@ -4,7 +4,7 @@
 
 #include "chrome/renderer/password_autocomplete_manager.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "chrome/common/render_messages.h"
@@ -302,7 +302,7 @@ void PasswordAutocompleteManager::TextFieldHandlingKeyDown(
 
   int win_key_code = event.windowsKeyCode;
   iter->second.backspace_pressed_last =
-      (win_key_code == base::VKEY_BACK || win_key_code == base::VKEY_DELETE);
+      (win_key_code == app::VKEY_BACK || win_key_code == app::VKEY_DELETE);
 }
 
 bool PasswordAutocompleteManager::InputElementClicked(
diff --git a/chrome/renderer/password_autocomplete_manager_unittest.cc b/chrome/renderer/password_autocomplete_manager_unittest.cc
index a799365..8b1f451 100644
--- a/chrome/renderer/password_autocomplete_manager_unittest.cc
+++ b/chrome/renderer/password_autocomplete_manager_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/password_autocomplete_manager.h"
@@ -116,7 +116,7 @@ class PasswordAutocompleteManagerTest : public RenderViewTest {
   }
 
   void SimulateKeyDownEvent(const WebInputElement& element,
-                            base::KeyboardCode key_code) {
+                            app::KeyboardCode key_code) {
     WebKit::WebKeyboardEvent key_event;
     key_event.windowsKeyCode = key_code;
     view_->textFieldDidReceiveKeyDown(element, key_event);
@@ -288,12 +288,12 @@ TEST_F(PasswordAutocompleteManagerTest, MAYBE_InlineAutocomplete) {
   CheckUsernameSelection(2, 5);
 
   // Test that deleting does not trigger autocomplete.
-  SimulateKeyDownEvent(username_element_, base::VKEY_BACK);
+  SimulateKeyDownEvent(username_element_, app::VKEY_BACK);
   SimulateUsernameChange("alic", true);
   CheckTextFieldsState("alic", false, "", false);
   CheckUsernameSelection(4, 4);  // No selection.
   // Reset the last pressed key to something other than backspace.
-  SimulateKeyDownEvent(username_element_, base::VKEY_A);
+  SimulateKeyDownEvent(username_element_, app::VKEY_A);
 
   // Now lets say the user goes astray from the stored username and types the
   // letter 'f', spelling 'alf'.  We don't know alf (that's just sad), so in
diff --git a/chrome/renderer/render_view_browsertest.cc b/chrome/renderer/render_view_browsertest.cc
index 35cdb6d..531aae7 100644
--- a/chrome/renderer/render_view_browsertest.cc
+++ b/chrome/renderer/render_view_browsertest.cc
@@ -4,8 +4,8 @@
 
 #include "base/basictypes.h"
 
+#include "app/keyboard_codes.h"
 #include "base/file_util.h"
-#include "base/keyboard_codes.h"
 #include "base/shared_memory.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/content_settings.h"
@@ -578,20 +578,20 @@ TEST_F(RenderViewTest, OnHandleKeyboardEvent) {
         'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
         'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
         'W', 'X', 'Y', 'Z',
-        base::VKEY_OEM_1,
-        base::VKEY_OEM_PLUS,
-        base::VKEY_OEM_COMMA,
-        base::VKEY_OEM_MINUS,
-        base::VKEY_OEM_PERIOD,
-        base::VKEY_OEM_2,
-        base::VKEY_OEM_3,
-        base::VKEY_OEM_4,
-        base::VKEY_OEM_5,
-        base::VKEY_OEM_6,
-        base::VKEY_OEM_7,
+        app::VKEY_OEM_1,
+        app::VKEY_OEM_PLUS,
+        app::VKEY_OEM_COMMA,
+        app::VKEY_OEM_MINUS,
+        app::VKEY_OEM_PERIOD,
+        app::VKEY_OEM_2,
+        app::VKEY_OEM_3,
+        app::VKEY_OEM_4,
+        app::VKEY_OEM_5,
+        app::VKEY_OEM_6,
+        app::VKEY_OEM_7,
 #if defined(OS_WIN)
         // Not sure how to handle this key on Linux.
-        base::VKEY_OEM_8,
+        app::VKEY_OEM_8,
 #endif
       };
 
@@ -817,20 +817,20 @@ TEST_F(RenderViewTest, InsertCharacters) {
         'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
         'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
         'W', 'X', 'Y', 'Z',
-        base::VKEY_OEM_1,
-        base::VKEY_OEM_PLUS,
-        base::VKEY_OEM_COMMA,
-        base::VKEY_OEM_MINUS,
-        base::VKEY_OEM_PERIOD,
-        base::VKEY_OEM_2,
-        base::VKEY_OEM_3,
-        base::VKEY_OEM_4,
-        base::VKEY_OEM_5,
-        base::VKEY_OEM_6,
-        base::VKEY_OEM_7,
+        app::VKEY_OEM_1,
+        app::VKEY_OEM_PLUS,
+        app::VKEY_OEM_COMMA,
+        app::VKEY_OEM_MINUS,
+        app::VKEY_OEM_PERIOD,
+        app::VKEY_OEM_2,
+        app::VKEY_OEM_3,
+        app::VKEY_OEM_4,
+        app::VKEY_OEM_5,
+        app::VKEY_OEM_6,
+        app::VKEY_OEM_7,
 #if defined(OS_WIN)
         // Unclear how to handle this on Linux.
-        base::VKEY_OEM_8,
+        app::VKEY_OEM_8,
 #endif
       };
 
diff --git a/chrome/test/automated_ui_tests/automated_ui_tests.cc b/chrome/test/automated_ui_tests/automated_ui_tests.cc
index 1aad575..759c84c7 100644
--- a/chrome/test/automated_ui_tests/automated_ui_tests.cc
+++ b/chrome/test/automated_ui_tests/automated_ui_tests.cc
@@ -6,10 +6,10 @@
 #include <string>
 #include <vector>
 
+#include "app/keyboard_codes.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_util.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ -486,35 +486,35 @@ bool AutomatedUITest::Options() {
 }
 
 bool AutomatedUITest::PressDownArrow() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_DOWN, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_DOWN, 0);
 }
 
 bool AutomatedUITest::PressEnterKey() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_RETURN, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_RETURN, 0);
 }
 
 bool AutomatedUITest::PressEscapeKey() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_ESCAPE, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_ESCAPE, 0);
 }
 
 bool AutomatedUITest::PressPageDown() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_PRIOR, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_PRIOR, 0);
 }
 
 bool AutomatedUITest::PressPageUp() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_NEXT, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_NEXT, 0);
 }
 
 bool AutomatedUITest::PressSpaceBar() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_SPACE, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_SPACE, 0);
 }
 
 bool AutomatedUITest::PressTabKey() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_TAB, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_TAB, 0);
 }
 
 bool AutomatedUITest::PressUpArrow() {
-  return SimulateKeyPressInActiveWindow(base::VKEY_UP, 0);
+  return SimulateKeyPressInActiveWindow(app::VKEY_UP, 0);
 }
 
 bool AutomatedUITest::StarPage() {
@@ -604,7 +604,7 @@ bool AutomatedUITest::ForceCrash() {
   return true;
 }
 
-bool AutomatedUITest::SimulateKeyPressInActiveWindow(base::KeyboardCode key,
+bool AutomatedUITest::SimulateKeyPressInActiveWindow(app::KeyboardCode key,
                                                      int flags) {
   scoped_refptr<WindowProxy> window(automation()->GetActiveWindow());
   if (window.get() == NULL) {
diff --git a/chrome/test/automated_ui_tests/automated_ui_tests.h b/chrome/test/automated_ui_tests/automated_ui_tests.h
index d26675c..ef7b1f3 100644
--- a/chrome/test/automated_ui_tests/automated_ui_tests.h
+++ b/chrome/test/automated_ui_tests/automated_ui_tests.h
@@ -103,7 +103,7 @@
 
 #include <string>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/test/automated_ui_tests/automated_ui_test_base.h"
 #include "chrome/test/ui/ui_test.h"
 
@@ -295,7 +295,7 @@ class AutomatedUITest : public AutomatedUITestBase {
   // Calls SimulateOSKeyPress on the active window. Simulates a key press at
   // the OS level. |key| is the key pressed  and |flags| specifies which
   // modifiers keys are also pressed (as defined in chrome/views/event.h).
-  bool SimulateKeyPressInActiveWindow(base::KeyboardCode key, int flags);
+  bool SimulateKeyPressInActiveWindow(app::KeyboardCode key, int flags);
 
   // Opens init file, reads it into the reader, and closes the file.
   // Returns false if there are any errors.
diff --git a/chrome/test/automation/automation_messages_internal.h b/chrome/test/automation/automation_messages_internal.h
index b08529b..0ef68ad 100644
--- a/chrome/test/automation/automation_messages_internal.h
+++ b/chrome/test/automation/automation_messages_internal.h
@@ -419,7 +419,7 @@ IPC_BEGIN_MESSAGES(Automation)
   // This message requests that a key press be performed.
   // Request:
   //   int - the handle of the window that's the context for this click
-  //   int - the base::KeyboardCode of the key that was pressed.
+  //   int - the app::KeyboardCode of the key that was pressed.
   //   int - the flags which identify the modifiers (shift, ctrl, alt)
   //         associated for, as defined in chrome/views/event.h
   IPC_MESSAGE_ROUTED3(AutomationMsg_WindowKeyPress, int, int, int)
diff --git a/chrome/test/automation/window_proxy.cc b/chrome/test/automation/window_proxy.cc
index c098abd..1a66edc 100644
--- a/chrome/test/automation/window_proxy.cc
+++ b/chrome/test/automation/window_proxy.cc
@@ -41,7 +41,7 @@ bool WindowProxy::GetWindowTitle(string16* text) {
   return sender_->Send(new AutomationMsg_WindowTitle(0, handle_, text));
 }
 
-bool WindowProxy::SimulateOSKeyPress(base::KeyboardCode key, int flags) {
+bool WindowProxy::SimulateOSKeyPress(app::KeyboardCode key, int flags) {
   if (!is_valid()) return false;
 
   return sender_->Send(
diff --git a/chrome/test/automation/window_proxy.h b/chrome/test/automation/window_proxy.h
index cb7b022..f0a9ac5 100644
--- a/chrome/test/automation/window_proxy.h
+++ b/chrome/test/automation/window_proxy.h
@@ -12,7 +12,7 @@
 #include <windows.h>
 #endif
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/string16.h"
 #include "base/thread.h"
 #include "chrome/test/automation/automation_handle_tracker.h"
@@ -54,7 +54,7 @@ class WindowProxy : public AutomationResourceProxy {
   // key pressed and |flags| specifies which modifiers keys are also pressed (as
   // defined in chrome/views/event.h).  Note that this actually sends the event
   // to the window that has focus.
-  bool SimulateOSKeyPress(base::KeyboardCode key, int flags);
+  bool SimulateOSKeyPress(app::KeyboardCode key, int flags);
 
   // Shows/hides the window and as a result makes it active/inactive.
   // Returns true if the call was successful.
diff --git a/chrome/test/interactive_ui/keyboard_access_uitest.cc b/chrome/test/interactive_ui/keyboard_access_uitest.cc
index 2fdd3e8..d002a3e 100644
--- a/chrome/test/interactive_ui/keyboard_access_uitest.cc
+++ b/chrome/test/interactive_ui/keyboard_access_uitest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
@@ -59,12 +59,12 @@ void KeyboardAccessTest::TestMenuKeyboardAccess(bool alternate_key_sequence) {
   int original_view_id = -1;
   ASSERT_TRUE(window->GetFocusedViewID(&original_view_id));
 
-  base::KeyboardCode menu_key =
-      alternate_key_sequence ? base::VKEY_MENU : base::VKEY_F10;
+  app::KeyboardCode menu_key =
+      alternate_key_sequence ? app::VKEY_MENU : app::VKEY_F10;
 #if defined(OS_CHROMEOS)
   // Chrome OS has different function key accelerators, so we always use the
   // menu key there.
-  menu_key = base::VKEY_MENU;
+  menu_key = app::VKEY_MENU;
 #endif
   ASSERT_TRUE(window->SimulateOSKeyPress(menu_key, 0));
 
@@ -75,16 +75,16 @@ void KeyboardAccessTest::TestMenuKeyboardAccess(bool alternate_key_sequence) {
   ASSERT_TRUE(browser->StartTrackingPopupMenus());
 
   if (alternate_key_sequence)
-    ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_DOWN, 0));
+    ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_DOWN, 0));
   else
-    ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_RETURN, 0));
+    ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_RETURN, 0));
 
   // Wait until the popup menu actually opens.
   ASSERT_TRUE(browser->WaitForPopupMenuToOpen());
 
   // Press DOWN to select the first item, then RETURN to select it.
-  ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_DOWN, 0));
-  ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_RETURN, 0));
+  ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_DOWN, 0));
+  ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_RETURN, 0));
 
   // Wait for the new tab to appear.
   ASSERT_TRUE(browser->WaitForTabCountToBecome(2, action_timeout_ms()));
@@ -125,13 +125,13 @@ TEST_F(KeyboardAccessTest, FAILS_ReserveKeyboardAccelerators) {
   scoped_refptr<WindowProxy> window(browser->GetWindow());
   ASSERT_TRUE(window);
   ASSERT_TRUE(window->SimulateOSKeyPress(
-      base::VKEY_TAB, views::Event::EF_CONTROL_DOWN));
+      app::VKEY_TAB, views::Event::EF_CONTROL_DOWN));
   ASSERT_TRUE(browser->WaitForTabToBecomeActive(0, action_max_timeout_ms()));
 
 #if !defined(OS_MACOSX)  // see BrowserWindowCocoa::GetCommandId
   ASSERT_TRUE(browser->ActivateTab(1));
   ASSERT_TRUE(window->SimulateOSKeyPress(
-      base::VKEY_F4, views::Event::EF_CONTROL_DOWN));
+      app::VKEY_F4, views::Event::EF_CONTROL_DOWN));
   ASSERT_TRUE(browser->WaitForTabCountToBecome(1, action_max_timeout_ms()));
 #endif
 }
diff --git a/chrome/test/interactive_ui/npapi_interactive_test.cc b/chrome/test/interactive_ui/npapi_interactive_test.cc
index 7965151..7a867d2 100644
--- a/chrome/test/interactive_ui/npapi_interactive_test.cc
+++ b/chrome/test/interactive_ui/npapi_interactive_test.cc
@@ -31,8 +31,8 @@
 // NPAPI interactive UI tests.
 //
 
+#include "app/keyboard_codes.h"
 #include "base/file_path.h"
-#include "base/keyboard_codes.h"
 #include "chrome/browser/net/url_request_mock_http_job.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
@@ -95,7 +95,7 @@ TEST_F(NPAPIVisiblePluginTester, GetURLRequest404Response) {
   automation()->WaitForAppModalDialog();
   scoped_refptr<WindowProxy> window(automation()->GetActiveWindow());
   ASSERT_TRUE(window.get());
-  ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_ESCAPE, 0));
+  ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_ESCAPE, 0));
 
   WaitForFinish("geturl_404_response", "1", url, kTestCompleteCookie,
                 kTestCompleteSuccess, action_max_timeout_ms());
@@ -114,7 +114,7 @@ TEST_F(NPAPIVisiblePluginTester, DISABLED_SelfDeletePluginInvokeAlert) {
   ASSERT_TRUE(automation()->WaitForAppModalDialog());
   scoped_refptr<WindowProxy> window(automation()->GetActiveWindow());
   ASSERT_TRUE(window.get());
-  ASSERT_TRUE(window->SimulateOSKeyPress(base::VKEY_ESCAPE, 0));
+  ASSERT_TRUE(window->SimulateOSKeyPress(app::VKEY_ESCAPE, 0));
 
   WaitForFinish("self_delete_plugin_invoke_alert", "1", url,
                 kTestCompleteCookie, kTestCompleteSuccess,
diff --git a/chrome/test/reliability/page_load_test.cc b/chrome/test/reliability/page_load_test.cc
index a903032..6289b56 100644
--- a/chrome/test/reliability/page_load_test.cc
+++ b/chrome/test/reliability/page_load_test.cc
@@ -36,11 +36,11 @@
 
 #include <fstream>
 
+#include "app/keyboard_codes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
-#include "base/keyboard_codes.h"
 #include "base/i18n/time_formatting.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
@@ -209,9 +209,9 @@ class PageLoadTest : public UITest {
             scoped_refptr<WindowProxy> window(browser->GetWindow());
             if (window.get()) {
               if (browser->BringToFront()) {
-                window->SimulateOSKeyPress(base::VKEY_NEXT, 0);
+                window->SimulateOSKeyPress(app::VKEY_NEXT, 0);
                 PlatformThread::Sleep(sleep_timeout_ms());
-                window->SimulateOSKeyPress(base::VKEY_NEXT, 0);
+                window->SimulateOSKeyPress(app::VKEY_NEXT, 0);
                 PlatformThread::Sleep(sleep_timeout_ms());
               }
             }
diff --git a/chrome/test/render_view_test.cc b/chrome/test/render_view_test.cc
index 9094525..848f440 100644
--- a/chrome/test/render_view_test.cc
+++ b/chrome/test/render_view_test.cc
@@ -26,7 +26,7 @@
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(OS_LINUX)
-#include "base/event_synthesis_gtk.h"
+#include "app/event_synthesis_gtk.h"
 #endif
 
 using WebKit::WebFrame;
@@ -188,8 +188,8 @@ int RenderViewTest::SendKeyEvent(MockKeyboard::Layout layout,
   // We ignore |layout|, which means we are only testing the layout of the
   // current locale. TODO(estade): fix this to respect |layout|.
   std::vector<GdkEvent*> events;
-  base::SynthesizeKeyPressEvents(
-      NULL, static_cast<base::KeyboardCode>(key_code),
+  app::SynthesizeKeyPressEvents(
+      NULL, static_cast<app::KeyboardCode>(key_code),
       modifiers & (MockKeyboard::LEFT_CONTROL | MockKeyboard::RIGHT_CONTROL),
       modifiers & (MockKeyboard::LEFT_SHIFT | MockKeyboard::RIGHT_SHIFT),
       modifiers & (MockKeyboard::LEFT_ALT | MockKeyboard::RIGHT_ALT),
diff --git a/chrome/test/ui_test_utils.cc b/chrome/test/ui_test_utils.cc
index 9c86038..ad0d3a7 100644
--- a/chrome/test/ui_test_utils.cc
+++ b/chrome/test/ui_test_utils.cc
@@ -551,7 +551,7 @@ void WaitForBookmarkModelToLoad(BookmarkModel* model) {
 }
 
 bool SendKeyPressSync(gfx::NativeWindow window,
-                      base::KeyboardCode key,
+                      app::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
diff --git a/chrome/test/ui_test_utils.h b/chrome/test/ui_test_utils.h
index 8ca8b02..28552d8 100644
--- a/chrome/test/ui_test_utils.h
+++ b/chrome/test/ui_test_utils.h
@@ -10,8 +10,8 @@
 #include <string>
 #include <set>
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string16.h"
@@ -193,7 +193,7 @@ void WaitForBookmarkModelToLoad(BookmarkModel* model);
 // out. This uses ui_controls::SendKeyPress, see it for details. Returns true
 // if the event was successfully sent and received.
 bool SendKeyPressSync(gfx::NativeWindow window,
-                      base::KeyboardCode key,
+                      app::KeyboardCode key,
                       bool control,
                       bool shift,
                       bool alt,
diff --git a/chrome/test/webdriver/keymap.cc b/chrome/test/webdriver/keymap.cc
index 6c3eac6..640bf45 100644
--- a/chrome/test/webdriver/keymap.cc
+++ b/chrome/test/webdriver/keymap.cc
@@ -14,132 +14,132 @@ KeyMap::KeyMap() {
   // 0xE000-0xF8FF.
 
   // Special WebDriver NULL key; clears all modifiers.
-  keys_[L'\uE000'] = base::VKEY_UNKNOWN;
-
-  keys_[L'\uE001'] = base::VKEY_UNKNOWN;  // TODO(jmikhail): CANCEL
-  keys_[L'\uE002'] = base::VKEY_HELP;
-  keys_[L'\uE003'] = base::VKEY_BACK;     // BACKSPACE
-  keys_[L'\uE004'] = base::VKEY_TAB;
-  keys_[L'\uE005'] = base::VKEY_CLEAR;
-  keys_[L'\uE006'] = base::VKEY_RETURN;
-  keys_[L'\uE007'] = base::VKEY_UNKNOWN;  // TODO(jmikhail): ENTER
-  keys_[L'\uE008'] = base::VKEY_SHIFT;
-  keys_[L'\uE009'] = base::VKEY_CONTROL;
-  keys_[L'\uE00A'] = base::VKEY_MENU;     // ALT
-  keys_[L'\uE00B'] = base::VKEY_PAUSE;
-  keys_[L'\uE00C'] = base::VKEY_ESCAPE;
-  keys_[L'\uE00D'] = base::VKEY_SPACE;
-  keys_[L'\uE00E'] = base::VKEY_PRIOR;    // PAGEUP
-  keys_[L'\uE00F'] = base::VKEY_NEXT;     // PAGEDOWN
-  keys_[L'\uE010'] = base::VKEY_END;
-  keys_[L'\uE011'] = base::VKEY_HOME;
-  keys_[L'\uE012'] = base::VKEY_LEFT;
-  keys_[L'\uE013'] = base::VKEY_UP;
-  keys_[L'\uE014'] = base::VKEY_RIGHT;
-  keys_[L'\uE015'] = base::VKEY_DOWN;
-  keys_[L'\uE016'] = base::VKEY_INSERT;
-  keys_[L'\uE017'] = base::VKEY_DELETE;
-
-  keys_[L'\uE01A'] = base::VKEY_NUMPAD0;
-  keys_[L'\uE01B'] = base::VKEY_NUMPAD1;
-  keys_[L'\uE01C'] = base::VKEY_NUMPAD2;
-  keys_[L'\uE01D'] = base::VKEY_NUMPAD3;
-  keys_[L'\uE01E'] = base::VKEY_NUMPAD4;
-  keys_[L'\uE01F'] = base::VKEY_NUMPAD5;
-  keys_[L'\uE020'] = base::VKEY_NUMPAD6;
-  keys_[L'\uE021'] = base::VKEY_NUMPAD7;
-  keys_[L'\uE022'] = base::VKEY_NUMPAD8;
-  keys_[L'\uE023'] = base::VKEY_NUMPAD9;
-  keys_[L'\uE024'] = base::VKEY_MULTIPLY;
-  keys_[L'\uE025'] = base::VKEY_ADD;
-  keys_[L'\uE026'] = base::VKEY_SEPARATOR;
-  keys_[L'\uE027'] = base::VKEY_SUBTRACT;
-  keys_[L'\uE028'] = base::VKEY_DECIMAL;
-  keys_[L'\uE029'] = base::VKEY_DIVIDE;
-
-  keys_[L'\uE031'] = base::VKEY_F1;
-  keys_[L'\uE032'] = base::VKEY_F2;
-  keys_[L'\uE033'] = base::VKEY_F3;
-  keys_[L'\uE034'] = base::VKEY_F4;
-  keys_[L'\uE035'] = base::VKEY_F5;
-  keys_[L'\uE036'] = base::VKEY_F6;
-  keys_[L'\uE037'] = base::VKEY_F7;
-  keys_[L'\uE038'] = base::VKEY_F8;
-  keys_[L'\uE039'] = base::VKEY_F9;
-  keys_[L'\uE03A'] = base::VKEY_F10;
-  keys_[L'\uE03B'] = base::VKEY_F11;
-  keys_[L'\uE03C'] = base::VKEY_F12;
+  keys_[L'\uE000'] = app::VKEY_UNKNOWN;
+
+  keys_[L'\uE001'] = app::VKEY_UNKNOWN;  // TODO(jmikhail): CANCEL
+  keys_[L'\uE002'] = app::VKEY_HELP;
+  keys_[L'\uE003'] = app::VKEY_BACK;     // BACKSPACE
+  keys_[L'\uE004'] = app::VKEY_TAB;
+  keys_[L'\uE005'] = app::VKEY_CLEAR;
+  keys_[L'\uE006'] = app::VKEY_RETURN;
+  keys_[L'\uE007'] = app::VKEY_UNKNOWN;  // TODO(jmikhail): ENTER
+  keys_[L'\uE008'] = app::VKEY_SHIFT;
+  keys_[L'\uE009'] = app::VKEY_CONTROL;
+  keys_[L'\uE00A'] = app::VKEY_MENU;     // ALT
+  keys_[L'\uE00B'] = app::VKEY_PAUSE;
+  keys_[L'\uE00C'] = app::VKEY_ESCAPE;
+  keys_[L'\uE00D'] = app::VKEY_SPACE;
+  keys_[L'\uE00E'] = app::VKEY_PRIOR;    // PAGEUP
+  keys_[L'\uE00F'] = app::VKEY_NEXT;     // PAGEDOWN
+  keys_[L'\uE010'] = app::VKEY_END;
+  keys_[L'\uE011'] = app::VKEY_HOME;
+  keys_[L'\uE012'] = app::VKEY_LEFT;
+  keys_[L'\uE013'] = app::VKEY_UP;
+  keys_[L'\uE014'] = app::VKEY_RIGHT;
+  keys_[L'\uE015'] = app::VKEY_DOWN;
+  keys_[L'\uE016'] = app::VKEY_INSERT;
+  keys_[L'\uE017'] = app::VKEY_DELETE;
+
+  keys_[L'\uE01A'] = app::VKEY_NUMPAD0;
+  keys_[L'\uE01B'] = app::VKEY_NUMPAD1;
+  keys_[L'\uE01C'] = app::VKEY_NUMPAD2;
+  keys_[L'\uE01D'] = app::VKEY_NUMPAD3;
+  keys_[L'\uE01E'] = app::VKEY_NUMPAD4;
+  keys_[L'\uE01F'] = app::VKEY_NUMPAD5;
+  keys_[L'\uE020'] = app::VKEY_NUMPAD6;
+  keys_[L'\uE021'] = app::VKEY_NUMPAD7;
+  keys_[L'\uE022'] = app::VKEY_NUMPAD8;
+  keys_[L'\uE023'] = app::VKEY_NUMPAD9;
+  keys_[L'\uE024'] = app::VKEY_MULTIPLY;
+  keys_[L'\uE025'] = app::VKEY_ADD;
+  keys_[L'\uE026'] = app::VKEY_SEPARATOR;
+  keys_[L'\uE027'] = app::VKEY_SUBTRACT;
+  keys_[L'\uE028'] = app::VKEY_DECIMAL;
+  keys_[L'\uE029'] = app::VKEY_DIVIDE;
+
+  keys_[L'\uE031'] = app::VKEY_F1;
+  keys_[L'\uE032'] = app::VKEY_F2;
+  keys_[L'\uE033'] = app::VKEY_F3;
+  keys_[L'\uE034'] = app::VKEY_F4;
+  keys_[L'\uE035'] = app::VKEY_F5;
+  keys_[L'\uE036'] = app::VKEY_F6;
+  keys_[L'\uE037'] = app::VKEY_F7;
+  keys_[L'\uE038'] = app::VKEY_F8;
+  keys_[L'\uE039'] = app::VKEY_F9;
+  keys_[L'\uE03A'] = app::VKEY_F10;
+  keys_[L'\uE03B'] = app::VKEY_F11;
+  keys_[L'\uE03C'] = app::VKEY_F12;
 
   // Common aliases.
-  keys_[L'\t'] = base::VKEY_TAB;
-  keys_[L'\n'] = base::VKEY_RETURN;
-  keys_[L'\r'] = base::VKEY_RETURN;
-  keys_[L'\b'] = base::VKEY_BACK;
+  keys_[L'\t'] = app::VKEY_TAB;
+  keys_[L'\n'] = app::VKEY_RETURN;
+  keys_[L'\r'] = app::VKEY_RETURN;
+  keys_[L'\b'] = app::VKEY_BACK;
 
-  keys_[L' '] = base::VKEY_SPACE;
+  keys_[L' '] = app::VKEY_SPACE;
 
   // Alpha keys match their ASCII values
   for (int i = 0; i < 26; ++i) {
     keys_[static_cast<wchar_t>(L'a' + i)] = \
-      static_cast<base::KeyboardCode>(base::VKEY_A + i);
+      static_cast<app::KeyboardCode>(app::VKEY_A + i);
     shifted_keys_[static_cast<wchar_t>(L'A' + i)] = \
-      static_cast<base::KeyboardCode>(base::VKEY_A + i);
+      static_cast<app::KeyboardCode>(app::VKEY_A + i);
   }
 
   // Numeric keys match their ASCII values
   for (int i = 0; i < 10; ++i) {
     keys_[static_cast<wchar_t>(L'0' + i)] = \
-      static_cast<base::KeyboardCode>(base::VKEY_0 + i);
+      static_cast<app::KeyboardCode>(app::VKEY_0 + i);
   }
 
   // The following all assumes the standard US keyboard.
   // TODO(jmikhail): Lookup correct keycode based on the current system keyboard
   // layout.  Right now it's fixed assuming standard ANSI
-  keys_[L'=']  = shifted_keys_[L'+'] = base::VKEY_OEM_PLUS;
-  keys_[L'-']  = shifted_keys_[L'_'] = base::VKEY_OEM_MINUS;
-  keys_[L';']  = shifted_keys_[L':'] = base::VKEY_OEM_1;
-  keys_[L'/']  = shifted_keys_[L'?'] = base::VKEY_OEM_2;
-  keys_[L'`']  = shifted_keys_[L'~'] = base::VKEY_OEM_3;
-  keys_[L'[']  = shifted_keys_[L'{'] = base::VKEY_OEM_4;
-  keys_[L'\\'] = shifted_keys_[L'|'] = base::VKEY_OEM_5;
-  keys_[L']']  = shifted_keys_[L'}'] = base::VKEY_OEM_6;
-  keys_[L'\''] = shifted_keys_[L'"'] = base::VKEY_OEM_7;
-  keys_[L',']  = shifted_keys_[L'<'] = base::VKEY_OEM_COMMA;
-  keys_[L'.']  = shifted_keys_[L'>'] = base::VKEY_OEM_PERIOD;
-  shifted_keys_[L'!'] = base::VKEY_1;
-  shifted_keys_[L'@'] = base::VKEY_2;
-  shifted_keys_[L'#'] = base::VKEY_3;
-  shifted_keys_[L'$'] = base::VKEY_4;
-  shifted_keys_[L'%'] = base::VKEY_5;
-  shifted_keys_[L'^'] = base::VKEY_6;
-  shifted_keys_[L'&'] = base::VKEY_7;
-  shifted_keys_[L'*'] = base::VKEY_8;
-  shifted_keys_[L'('] = base::VKEY_9;
-  shifted_keys_[L')'] = base::VKEY_0;
+  keys_[L'=']  = shifted_keys_[L'+'] = app::VKEY_OEM_PLUS;
+  keys_[L'-']  = shifted_keys_[L'_'] = app::VKEY_OEM_MINUS;
+  keys_[L';']  = shifted_keys_[L':'] = app::VKEY_OEM_1;
+  keys_[L'/']  = shifted_keys_[L'?'] = app::VKEY_OEM_2;
+  keys_[L'`']  = shifted_keys_[L'~'] = app::VKEY_OEM_3;
+  keys_[L'[']  = shifted_keys_[L'{'] = app::VKEY_OEM_4;
+  keys_[L'\\'] = shifted_keys_[L'|'] = app::VKEY_OEM_5;
+  keys_[L']']  = shifted_keys_[L'}'] = app::VKEY_OEM_6;
+  keys_[L'\''] = shifted_keys_[L'"'] = app::VKEY_OEM_7;
+  keys_[L',']  = shifted_keys_[L'<'] = app::VKEY_OEM_COMMA;
+  keys_[L'.']  = shifted_keys_[L'>'] = app::VKEY_OEM_PERIOD;
+  shifted_keys_[L'!'] = app::VKEY_1;
+  shifted_keys_[L'@'] = app::VKEY_2;
+  shifted_keys_[L'#'] = app::VKEY_3;
+  shifted_keys_[L'$'] = app::VKEY_4;
+  shifted_keys_[L'%'] = app::VKEY_5;
+  shifted_keys_[L'^'] = app::VKEY_6;
+  shifted_keys_[L'&'] = app::VKEY_7;
+  shifted_keys_[L'*'] = app::VKEY_8;
+  shifted_keys_[L'('] = app::VKEY_9;
+  shifted_keys_[L')'] = app::VKEY_0;
 }
 
-base::KeyboardCode KeyMap::Get(const wchar_t& key) const {
-  std::map<wchar_t, base::KeyboardCode>::const_iterator it;
+app::KeyboardCode KeyMap::Get(const wchar_t& key) const {
+  std::map<wchar_t, app::KeyboardCode>::const_iterator it;
   it = keys_.find(key);
   if (it == keys_.end()) {
     it = shifted_keys_.find(key);
     if (it == shifted_keys_.end()) {
-      return base::VKEY_UNKNOWN;
+      return app::VKEY_UNKNOWN;
     }
   }
   return it->second;
 }
 
 bool KeyMap::Press(const scoped_refptr<WindowProxy>& window,
-                   const base::KeyboardCode key_code,
+                   const app::KeyboardCode key_code,
                    const wchar_t& key) {
-  if (key_code == base::VKEY_SHIFT) {
+  if (key_code == app::VKEY_SHIFT) {
     shift_ = !shift_;
-  } else if (key_code == base::VKEY_CONTROL) {
+  } else if (key_code == app::VKEY_CONTROL) {
     control_ = !control_;
-  } else if (key_code == base::VKEY_MENU) {  // ALT
+  } else if (key_code == app::VKEY_MENU) {  // ALT
     alt_ = !alt_;
-  } else if (key_code == base::VKEY_COMMAND) {
+  } else if (key_code == app::VKEY_COMMAND) {
     command_ = !command_;
   }
 
diff --git a/chrome/test/webdriver/keymap.h b/chrome/test/webdriver/keymap.h
index 688ffa7..e4b1594 100644
--- a/chrome/test/webdriver/keymap.h
+++ b/chrome/test/webdriver/keymap.h
@@ -7,7 +7,7 @@
 
 #include <map>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "chrome/test/automation/window_proxy.h"
 
 namespace webdriver {
@@ -16,10 +16,10 @@ namespace webdriver {
 class KeyMap {
  public:
   KeyMap();
-  base::KeyboardCode Get(const wchar_t& key) const;
+  app::KeyboardCode Get(const wchar_t& key) const;
 
   bool Press(const scoped_refptr<WindowProxy>& window,
-             const base::KeyboardCode key_code,
+             const app::KeyboardCode key_code,
              const wchar_t& key);
 
   // Sets the Shift, Alt, Cntl, and Cmd keys to not pressed
@@ -30,8 +30,8 @@ class KeyMap {
   bool alt_;
   bool control_;
   bool command_;
-  std::map<wchar_t, base::KeyboardCode> keys_;
-  std::map<wchar_t, base::KeyboardCode> shifted_keys_;
+  std::map<wchar_t, app::KeyboardCode> keys_;
+  std::map<wchar_t, app::KeyboardCode> shifted_keys_;
   DISALLOW_COPY_AND_ASSIGN(KeyMap);
 };
 }  // namespace webdriver
diff --git a/remoting/DEPS b/remoting/DEPS
index f903045..4370b43 100644
--- a/remoting/DEPS
+++ b/remoting/DEPS
@@ -1,4 +1,5 @@
 include_rules = [
+  "+app",
   "+gfx",
   "+google/protobuf",
   "+media/base",
diff --git a/remoting/host/event_executor_win.cc b/remoting/host/event_executor_win.cc
index e1e57fa..e9c96ed 100644
--- a/remoting/host/event_executor_win.cc
+++ b/remoting/host/event_executor_win.cc
@@ -5,7 +5,7 @@
 #include "remoting/host/event_executor_win.h"
 
 #include <windows.h>
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/stl_util-inl.h"
 #include "remoting/host/capturer.h"
 
@@ -13,338 +13,338 @@ namespace remoting {
 
 // TODO(hclam): Move this method to base.
 // TODO(hclam): Using values look ugly, change it to something else.
-static base::KeyboardCode WindowsKeyCodeForPosixKeyCode(int keycode) {
+static app::KeyboardCode WindowsKeyCodeForPosixKeyCode(int keycode) {
   switch (keycode) {
     case 0x08:
-      return base::VKEY_BACK;
+      return app::VKEY_BACK;
     case 0x09:
-      return base::VKEY_TAB;
+      return app::VKEY_TAB;
     case 0x0C:
-      return base::VKEY_CLEAR;
+      return app::VKEY_CLEAR;
     case 0x0D:
-      return base::VKEY_RETURN;
+      return app::VKEY_RETURN;
     case 0x10:
-      return base::VKEY_SHIFT;
+      return app::VKEY_SHIFT;
     case 0x11:
-      return base::VKEY_CONTROL;
+      return app::VKEY_CONTROL;
     case 0x12:
-      return base::VKEY_MENU;
+      return app::VKEY_MENU;
     case 0x13:
-      return base::VKEY_PAUSE;
+      return app::VKEY_PAUSE;
     case 0x14:
-      return base::VKEY_CAPITAL;
+      return app::VKEY_CAPITAL;
     case 0x15:
-      return base::VKEY_KANA;
+      return app::VKEY_KANA;
     case 0x17:
-      return base::VKEY_JUNJA;
+      return app::VKEY_JUNJA;
     case 0x18:
-      return base::VKEY_FINAL;
+      return app::VKEY_FINAL;
     case 0x19:
-      return base::VKEY_KANJI;
+      return app::VKEY_KANJI;
     case 0x1B:
-      return base::VKEY_ESCAPE;
+      return app::VKEY_ESCAPE;
     case 0x1C:
-      return base::VKEY_CONVERT;
+      return app::VKEY_CONVERT;
     case 0x1D:
-      return base::VKEY_NONCONVERT;
+      return app::VKEY_NONCONVERT;
     case 0x1E:
-      return base::VKEY_ACCEPT;
+      return app::VKEY_ACCEPT;
     case 0x1F:
-      return base::VKEY_MODECHANGE;
+      return app::VKEY_MODECHANGE;
     case 0x20:
-      return base::VKEY_SPACE;
+      return app::VKEY_SPACE;
     case 0x21:
-      return base::VKEY_PRIOR;
+      return app::VKEY_PRIOR;
     case 0x22:
-      return base::VKEY_NEXT;
+      return app::VKEY_NEXT;
     case 0x23:
-      return base::VKEY_END;
+      return app::VKEY_END;
     case 0x24:
-      return base::VKEY_HOME;
+      return app::VKEY_HOME;
     case 0x25:
-      return base::VKEY_LEFT;
+      return app::VKEY_LEFT;
     case 0x26:
-      return base::VKEY_UP;
+      return app::VKEY_UP;
     case 0x27:
-      return base::VKEY_RIGHT;
+      return app::VKEY_RIGHT;
     case 0x28:
-      return base::VKEY_DOWN;
+      return app::VKEY_DOWN;
     case 0x29:
-      return base::VKEY_SELECT;
+      return app::VKEY_SELECT;
     case 0x2A:
-      return base::VKEY_PRINT;
+      return app::VKEY_PRINT;
     case 0x2B:
-      return base::VKEY_EXECUTE;
+      return app::VKEY_EXECUTE;
     case 0x2C:
-      return base::VKEY_SNAPSHOT;
+      return app::VKEY_SNAPSHOT;
     case 0x2D:
-      return base::VKEY_INSERT;
+      return app::VKEY_INSERT;
     case 0x2E:
-      return base::VKEY_DELETE;
+      return app::VKEY_DELETE;
     case 0x2F:
-      return base::VKEY_HELP;
+      return app::VKEY_HELP;
     case 0x30:
-      return base::VKEY_0;
+      return app::VKEY_0;
     case 0x31:
-      return base::VKEY_1;
+      return app::VKEY_1;
     case 0x32:
-      return base::VKEY_2;
+      return app::VKEY_2;
     case 0x33:
-      return base::VKEY_3;
+      return app::VKEY_3;
     case 0x34:
-      return base::VKEY_4;
+      return app::VKEY_4;
     case 0x35:
-      return base::VKEY_5;
+      return app::VKEY_5;
     case 0x36:
-      return base::VKEY_6;
+      return app::VKEY_6;
     case 0x37:
-      return base::VKEY_7;
+      return app::VKEY_7;
     case 0x38:
-      return base::VKEY_8;
+      return app::VKEY_8;
     case 0x39:
-      return base::VKEY_9;
+      return app::VKEY_9;
     case 0x41:
-      return base::VKEY_A;
+      return app::VKEY_A;
     case 0x42:
-      return base::VKEY_B;
+      return app::VKEY_B;
     case 0x43:
-      return base::VKEY_C;
+      return app::VKEY_C;
     case 0x44:
-      return base::VKEY_D;
+      return app::VKEY_D;
     case 0x45:
-      return base::VKEY_E;
+      return app::VKEY_E;
     case 0x46:
-      return base::VKEY_F;
+      return app::VKEY_F;
     case 0x47:
-      return base::VKEY_G;
+      return app::VKEY_G;
     case 0x48:
-      return base::VKEY_H;
+      return app::VKEY_H;
     case 0x49:
-      return base::VKEY_I;
+      return app::VKEY_I;
     case 0x4A:
-      return base::VKEY_J;
+      return app::VKEY_J;
     case 0x4B:
-      return base::VKEY_K;
+      return app::VKEY_K;
     case 0x4C:
-      return base::VKEY_L;
+      return app::VKEY_L;
     case 0x4D:
-      return base::VKEY_M;
+      return app::VKEY_M;
     case 0x4E:
-      return base::VKEY_N;
+      return app::VKEY_N;
     case 0x4F:
-      return base::VKEY_O;
+      return app::VKEY_O;
     case 0x50:
-      return base::VKEY_P;
+      return app::VKEY_P;
     case 0x51:
-      return base::VKEY_Q;
+      return app::VKEY_Q;
     case 0x52:
-      return base::VKEY_R;
+      return app::VKEY_R;
     case 0x53:
-      return base::VKEY_S;
+      return app::VKEY_S;
     case 0x54:
-      return base::VKEY_T;
+      return app::VKEY_T;
     case 0x55:
-      return base::VKEY_U;
+      return app::VKEY_U;
     case 0x56:
-      return base::VKEY_V;
+      return app::VKEY_V;
     case 0x57:
-      return base::VKEY_W;
+      return app::VKEY_W;
     case 0x58:
-      return base::VKEY_X;
+      return app::VKEY_X;
     case 0x59:
-      return base::VKEY_Y;
+      return app::VKEY_Y;
     case 0x5A:
-      return base::VKEY_Z;
+      return app::VKEY_Z;
     case 0x5B:
-      return base::VKEY_LWIN;
+      return app::VKEY_LWIN;
     case 0x5C:
-      return base::VKEY_RWIN;
+      return app::VKEY_RWIN;
     case 0x5D:
-      return base::VKEY_APPS;
+      return app::VKEY_APPS;
     case 0x5F:
-      return base::VKEY_SLEEP;
+      return app::VKEY_SLEEP;
     case 0x60:
-      return base::VKEY_NUMPAD0;
+      return app::VKEY_NUMPAD0;
     case 0x61:
-      return base::VKEY_NUMPAD1;
+      return app::VKEY_NUMPAD1;
     case 0x62:
-      return base::VKEY_NUMPAD2;
+      return app::VKEY_NUMPAD2;
     case 0x63:
-      return base::VKEY_NUMPAD3;
+      return app::VKEY_NUMPAD3;
     case 0x64:
-      return base::VKEY_NUMPAD4;
+      return app::VKEY_NUMPAD4;
     case 0x65:
-      return base::VKEY_NUMPAD5;
+      return app::VKEY_NUMPAD5;
     case 0x66:
-      return base::VKEY_NUMPAD6;
+      return app::VKEY_NUMPAD6;
     case 0x67:
-      return base::VKEY_NUMPAD7;
+      return app::VKEY_NUMPAD7;
     case 0x68:
-      return base::VKEY_NUMPAD8;
+      return app::VKEY_NUMPAD8;
     case 0x69:
-      return base::VKEY_NUMPAD9;
+      return app::VKEY_NUMPAD9;
     case 0x6A:
-      return base::VKEY_MULTIPLY;
+      return app::VKEY_MULTIPLY;
     case 0x6B:
-      return base::VKEY_ADD;
+      return app::VKEY_ADD;
     case 0x6C:
-      return base::VKEY_SEPARATOR;
+      return app::VKEY_SEPARATOR;
     case 0x6D:
-      return base::VKEY_SUBTRACT;
+      return app::VKEY_SUBTRACT;
     case 0x6E:
-      return base::VKEY_DECIMAL;
+      return app::VKEY_DECIMAL;
     case 0x6F:
-      return base::VKEY_DIVIDE;
+      return app::VKEY_DIVIDE;
     case 0x70:
-      return base::VKEY_F1;
+      return app::VKEY_F1;
     case 0x71:
-      return base::VKEY_F2;
+      return app::VKEY_F2;
     case 0x72:
-      return base::VKEY_F3;
+      return app::VKEY_F3;
     case 0x73:
-      return base::VKEY_F4;
+      return app::VKEY_F4;
     case 0x74:
-      return base::VKEY_F5;
+      return app::VKEY_F5;
     case 0x75:
-      return base::VKEY_F6;
+      return app::VKEY_F6;
     case 0x76:
-      return base::VKEY_F7;
+      return app::VKEY_F7;
     case 0x77:
-      return base::VKEY_F8;
+      return app::VKEY_F8;
     case 0x78:
-      return base::VKEY_F9;
+      return app::VKEY_F9;
     case 0x79:
-      return base::VKEY_F10;
+      return app::VKEY_F10;
     case 0x7A:
-      return base::VKEY_F11;
+      return app::VKEY_F11;
     case 0x7B:
-      return base::VKEY_F12;
+      return app::VKEY_F12;
     case 0x7C:
-      return base::VKEY_F13;
+      return app::VKEY_F13;
     case 0x7D:
-      return base::VKEY_F14;
+      return app::VKEY_F14;
     case 0x7E:
-      return base::VKEY_F15;
+      return app::VKEY_F15;
     case 0x7F:
-      return base::VKEY_F16;
+      return app::VKEY_F16;
     case 0x80:
-      return base::VKEY_F17;
+      return app::VKEY_F17;
     case 0x81:
-      return base::VKEY_F18;
+      return app::VKEY_F18;
     case 0x82:
-      return base::VKEY_F19;
+      return app::VKEY_F19;
     case 0x83:
-      return base::VKEY_F20;
+      return app::VKEY_F20;
     case 0x84:
-      return base::VKEY_F21;
+      return app::VKEY_F21;
     case 0x85:
-      return base::VKEY_F22;
+      return app::VKEY_F22;
     case 0x86:
-      return base::VKEY_F23;
+      return app::VKEY_F23;
     case 0x87:
-      return base::VKEY_F24;
+      return app::VKEY_F24;
     case 0x90:
-      return base::VKEY_NUMLOCK;
+      return app::VKEY_NUMLOCK;
     case 0x91:
-      return base::VKEY_SCROLL;
+      return app::VKEY_SCROLL;
     case 0xA0:
-      return base::VKEY_LSHIFT;
+      return app::VKEY_LSHIFT;
     case 0xA1:
-      return base::VKEY_RSHIFT;
+      return app::VKEY_RSHIFT;
     case 0xA2:
-      return base::VKEY_LCONTROL;
+      return app::VKEY_LCONTROL;
     case 0xA3:
-      return base::VKEY_RCONTROL;
+      return app::VKEY_RCONTROL;
     case 0xA4:
-      return base::VKEY_LMENU;
+      return app::VKEY_LMENU;
     case 0xA5:
-      return base::VKEY_RMENU;
+      return app::VKEY_RMENU;
     case 0xA6:
-      return base::VKEY_BROWSER_BACK;
+      return app::VKEY_BROWSER_BACK;
     case 0xA7:
-      return base::VKEY_BROWSER_FORWARD;
+      return app::VKEY_BROWSER_FORWARD;
     case 0xA8:
-      return base::VKEY_BROWSER_REFRESH;
+      return app::VKEY_BROWSER_REFRESH;
     case 0xA9:
-      return base::VKEY_BROWSER_STOP;
+      return app::VKEY_BROWSER_STOP;
     case 0xAA:
-      return base::VKEY_BROWSER_SEARCH;
+      return app::VKEY_BROWSER_SEARCH;
     case 0xAB:
-      return base::VKEY_BROWSER_FAVORITES;
+      return app::VKEY_BROWSER_FAVORITES;
     case 0xAC:
-      return base::VKEY_BROWSER_HOME;
+      return app::VKEY_BROWSER_HOME;
     case 0xAD:
-      return base::VKEY_VOLUME_MUTE;
+      return app::VKEY_VOLUME_MUTE;
     case 0xAE:
-      return base::VKEY_VOLUME_DOWN;
+      return app::VKEY_VOLUME_DOWN;
     case 0xAF:
-      return base::VKEY_VOLUME_UP;
+      return app::VKEY_VOLUME_UP;
     case 0xB0:
-      return base::VKEY_MEDIA_NEXT_TRACK;
+      return app::VKEY_MEDIA_NEXT_TRACK;
     case 0xB1:
-      return base::VKEY_MEDIA_PREV_TRACK;
+      return app::VKEY_MEDIA_PREV_TRACK;
     case 0xB2:
-      return base::VKEY_MEDIA_STOP;
+      return app::VKEY_MEDIA_STOP;
     case 0xB3:
-      return base::VKEY_MEDIA_PLAY_PAUSE;
+      return app::VKEY_MEDIA_PLAY_PAUSE;
     case 0xB4:
-      return base::VKEY_MEDIA_LAUNCH_MAIL;
+      return app::VKEY_MEDIA_LAUNCH_MAIL;
     case 0xB5:
-      return base::VKEY_MEDIA_LAUNCH_MEDIA_SELECT;
+      return app::VKEY_MEDIA_LAUNCH_MEDIA_SELECT;
     case 0xB6:
-      return base::VKEY_MEDIA_LAUNCH_APP1;
+      return app::VKEY_MEDIA_LAUNCH_APP1;
     case 0xB7:
-      return base::VKEY_MEDIA_LAUNCH_APP2;
+      return app::VKEY_MEDIA_LAUNCH_APP2;
     case 0xBA:
-      return base::VKEY_OEM_1;
+      return app::VKEY_OEM_1;
     case 0xBB:
-      return base::VKEY_OEM_PLUS;
+      return app::VKEY_OEM_PLUS;
     case 0xBC:
-      return base::VKEY_OEM_COMMA;
+      return app::VKEY_OEM_COMMA;
     case 0xBD:
-      return base::VKEY_OEM_MINUS;
+      return app::VKEY_OEM_MINUS;
     case 0xBE:
-      return base::VKEY_OEM_PERIOD;
+      return app::VKEY_OEM_PERIOD;
     case 0xBF:
-      return base::VKEY_OEM_2;
+      return app::VKEY_OEM_2;
     case 0xC0:
-      return base::VKEY_OEM_3;
+      return app::VKEY_OEM_3;
     case 0xDB:
-      return base::VKEY_OEM_4;
+      return app::VKEY_OEM_4;
     case 0xDC:
-      return base::VKEY_OEM_5;
+      return app::VKEY_OEM_5;
     case 0xDD:
-      return base::VKEY_OEM_6;
+      return app::VKEY_OEM_6;
     case 0xDE:
-      return base::VKEY_OEM_7;
+      return app::VKEY_OEM_7;
     case 0xDF:
-      return base::VKEY_OEM_8;
+      return app::VKEY_OEM_8;
     case 0xE2:
-      return base::VKEY_OEM_102;
+      return app::VKEY_OEM_102;
     case 0xE5:
-      return base::VKEY_PROCESSKEY;
+      return app::VKEY_PROCESSKEY;
     case 0xE7:
-      return base::VKEY_PACKET;
+      return app::VKEY_PACKET;
     case 0xF6:
-      return base::VKEY_ATTN;
+      return app::VKEY_ATTN;
     case 0xF7:
-      return base::VKEY_CRSEL;
+      return app::VKEY_CRSEL;
     case 0xF8:
-      return base::VKEY_EXSEL;
+      return app::VKEY_EXSEL;
     case 0xF9:
-      return base::VKEY_EREOF;
+      return app::VKEY_EREOF;
     case 0xFA:
-      return base::VKEY_PLAY;
+      return app::VKEY_PLAY;
     case 0xFB:
-      return base::VKEY_ZOOM;
+      return app::VKEY_ZOOM;
     case 0xFC:
-      return base::VKEY_NONAME;
+      return app::VKEY_NONAME;
     case 0xFD:
-      return base::VKEY_PA1;
+      return app::VKEY_PA1;
     case 0xFE:
-      return base::VKEY_OEM_CLEAR;
+      return app::VKEY_OEM_CLEAR;
     default:
-      return base::VKEY_UNKNOWN;
+      return app::VKEY_UNKNOWN;
   }
 }
 
diff --git a/views/accelerator.cc b/views/accelerator.cc
index 730191d..6b80cc4 100644
--- a/views/accelerator.cc
+++ b/views/accelerator.cc
@@ -22,46 +22,46 @@ namespace views {
 std::wstring Accelerator::GetShortcutText() const {
   int string_id = 0;
   switch(key_code_) {
-    case base::VKEY_TAB:
+    case app::VKEY_TAB:
       string_id = IDS_APP_TAB_KEY;
       break;
-    case base::VKEY_RETURN:
+    case app::VKEY_RETURN:
       string_id = IDS_APP_ENTER_KEY;
       break;
-    case base::VKEY_ESCAPE:
+    case app::VKEY_ESCAPE:
       string_id = IDS_APP_ESC_KEY;
       break;
-    case base::VKEY_PRIOR:
+    case app::VKEY_PRIOR:
       string_id = IDS_APP_PAGEUP_KEY;
       break;
-    case base::VKEY_NEXT:
+    case app::VKEY_NEXT:
       string_id = IDS_APP_PAGEDOWN_KEY;
       break;
-    case base::VKEY_END:
+    case app::VKEY_END:
       string_id = IDS_APP_END_KEY;
       break;
-    case base::VKEY_HOME:
+    case app::VKEY_HOME:
       string_id = IDS_APP_HOME_KEY;
       break;
-    case base::VKEY_INSERT:
+    case app::VKEY_INSERT:
       string_id = IDS_APP_INSERT_KEY;
       break;
-    case base::VKEY_DELETE:
+    case app::VKEY_DELETE:
       string_id = IDS_APP_DELETE_KEY;
       break;
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       string_id = IDS_APP_LEFT_ARROW_KEY;
       break;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       string_id = IDS_APP_RIGHT_ARROW_KEY;
       break;
-    case base::VKEY_BACK:
+    case app::VKEY_BACK:
       string_id = IDS_APP_BACKSPACE_KEY;
       break;
-    case base::VKEY_F1:
+    case app::VKEY_F1:
       string_id = IDS_APP_F1_KEY;
       break;
-    case base::VKEY_F11:
+    case app::VKEY_F11:
       string_id = IDS_APP_F11_KEY;
       break;
     default:
diff --git a/views/accelerator.h b/views/accelerator.h
index 08dc201..5cf68f1 100644
--- a/views/accelerator.h
+++ b/views/accelerator.h
@@ -23,10 +23,10 @@ class Accelerator : public menus::Accelerator {
  public:
   Accelerator() : menus::Accelerator() {}
 
-  Accelerator(base::KeyboardCode keycode, int modifiers)
+  Accelerator(app::KeyboardCode keycode, int modifiers)
       : menus::Accelerator(keycode, modifiers) {}
 
-  Accelerator(base::KeyboardCode keycode,
+  Accelerator(app::KeyboardCode keycode,
               bool shift_pressed, bool ctrl_pressed, bool alt_pressed) {
     key_code_ = keycode;
     modifiers_ = 0;
diff --git a/views/controls/button/custom_button.cc b/views/controls/button/custom_button.cc
index 04ff856..bc949c1 100644
--- a/views/controls/button/custom_button.cc
+++ b/views/controls/button/custom_button.cc
@@ -4,8 +4,8 @@
 
 #include "views/controls/button/custom_button.h"
 
+#include "app/keyboard_codes.h"
 #include "app/throb_animation.h"
-#include "base/keyboard_codes.h"
 #include "views/screen.h"
 
 namespace views {
@@ -192,9 +192,9 @@ bool CustomButton::OnKeyPressed(const KeyEvent& e) {
   // Space sets button state to pushed. Enter clicks the button. This matches
   // the Windows native behavior of buttons, where Space clicks the button on
   // KeyRelease and Enter clicks the button on KeyPressed.
-  if (e.GetKeyCode() == base::VKEY_SPACE) {
+  if (e.GetKeyCode() == app::VKEY_SPACE) {
     SetState(BS_PUSHED);
-  } else if (e.GetKeyCode() == base::VKEY_RETURN) {
+  } else if (e.GetKeyCode() == app::VKEY_RETURN) {
     SetState(BS_NORMAL);
     NotifyClick(e);
   } else {
@@ -204,7 +204,7 @@ bool CustomButton::OnKeyPressed(const KeyEvent& e) {
 }
 
 bool CustomButton::OnKeyReleased(const KeyEvent& e) {
-  if ((state_ == BS_DISABLED) || (e.GetKeyCode() != base::VKEY_SPACE))
+  if ((state_ == BS_DISABLED) || (e.GetKeyCode() != app::VKEY_SPACE))
     return false;
 
   SetState(BS_NORMAL);
diff --git a/views/controls/button/menu_button.cc b/views/controls/button/menu_button.cc
index f09b2d4..4973ea2 100644
--- a/views/controls/button/menu_button.cc
+++ b/views/controls/button/menu_button.cc
@@ -219,10 +219,10 @@ void MenuButton::OnMouseReleased(const MouseEvent& e,
 }
 
 bool MenuButton::OnKeyPressed(const KeyEvent& e) {
-  if (e.GetKeyCode() == base::VKEY_SPACE ||
-      e.GetKeyCode() == base::VKEY_RETURN ||
-      e.GetKeyCode() == base::VKEY_UP ||
-      e.GetKeyCode() == base::VKEY_DOWN) {
+  if (e.GetKeyCode() == app::VKEY_SPACE ||
+      e.GetKeyCode() == app::VKEY_RETURN ||
+      e.GetKeyCode() == app::VKEY_UP ||
+      e.GetKeyCode() == app::VKEY_DOWN) {
     bool result = Activate();
     if (GetFocusManager()->GetFocusedView() == NULL)
       RequestFocus();
diff --git a/views/controls/button/native_button.cc b/views/controls/button/native_button.cc
index 4c66b9f..89dae9c 100644
--- a/views/controls/button/native_button.cc
+++ b/views/controls/button/native_button.cc
@@ -4,8 +4,8 @@
 
 #include "views/controls/button/native_button.h"
 
+#include "app/keyboard_codes.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_codes.h"
 #include "views/controls/native/native_view_host.h"
 
 #if defined(OS_WIN)
@@ -90,9 +90,9 @@ void NativeButton::SetIsDefault(bool is_default) {
   if (is_default == is_default_)
     return;
   if (is_default)
-    AddAccelerator(Accelerator(base::VKEY_RETURN, false, false, false));
+    AddAccelerator(Accelerator(app::VKEY_RETURN, false, false, false));
   else
-    RemoveAccelerator(Accelerator(base::VKEY_RETURN, false, false, false));
+    RemoveAccelerator(Accelerator(app::VKEY_RETURN, false, false, false));
   SetAppearsAsDefault(is_default);
 }
 
diff --git a/views/controls/combobox/combobox.cc b/views/controls/combobox/combobox.cc
index 0c24a0d..3eed917 100644
--- a/views/controls/combobox/combobox.cc
+++ b/views/controls/combobox/combobox.cc
@@ -5,7 +5,7 @@
 #include "views/controls/combobox/combobox.h"
 
 #include "app/combobox_model.h"
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "views/controls/combobox/native_combobox_wrapper.h"
@@ -75,7 +75,7 @@ void Combobox::SetEnabled(bool flag) {
 // VKEY_ESCAPE should be handled by this view when the drop down list is active.
 // In other words, the list should be closed instead of the dialog.
 bool Combobox::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
-  if (e.GetKeyCode() != base::VKEY_ESCAPE ||
+  if (e.GetKeyCode() != app::VKEY_ESCAPE ||
       e.IsShiftDown() || e.IsControlDown() || e.IsAltDown()) {
     return false;
   }
diff --git a/views/controls/link.cc b/views/controls/link.cc
index 97dc01f..6cf81d3 100644
--- a/views/controls/link.cc
+++ b/views/controls/link.cc
@@ -8,7 +8,7 @@
 #include <gdk/gdk.h>
 #endif
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "gfx/color_utils.h"
 #include "gfx/font.h"
@@ -122,8 +122,8 @@ void Link::OnMouseReleased(const MouseEvent& e, bool canceled) {
 }
 
 bool Link::OnKeyPressed(const KeyEvent& e) {
-  bool activate = ((e.GetKeyCode() == base::VKEY_SPACE) ||
-                   (e.GetKeyCode() == base::VKEY_RETURN));
+  bool activate = ((e.GetKeyCode() == app::VKEY_SPACE) ||
+                   (e.GetKeyCode() == app::VKEY_RETURN));
   if (!activate)
     return false;
 
@@ -140,8 +140,8 @@ bool Link::OnKeyPressed(const KeyEvent& e) {
 
 bool Link::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
   // Make sure we don't process space or enter as accelerators.
-  return (e.GetKeyCode() == base::VKEY_SPACE) ||
-      (e.GetKeyCode() == base::VKEY_RETURN);
+  return (e.GetKeyCode() == app::VKEY_SPACE) ||
+      (e.GetKeyCode() == app::VKEY_RETURN);
 }
 
 bool Link::GetAccessibleRole(AccessibilityTypes::Role* role) {
diff --git a/views/controls/menu/menu_controller.cc b/views/controls/menu/menu_controller.cc
index d5abe50..276226c 100644
--- a/views/controls/menu/menu_controller.cc
+++ b/views/controls/menu/menu_controller.cc
@@ -4,10 +4,10 @@
 
 #include "views/controls/menu/menu_controller.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_codes.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/canvas_skia.h"
@@ -22,7 +22,7 @@
 #include "views/widget/widget.h"
 
 #if defined(OS_LINUX)
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 #endif
 
 using base::Time;
@@ -813,8 +813,8 @@ bool MenuController::Dispatch(GdkEvent* event) {
 
   switch (event->type) {
     case GDK_KEY_PRESS: {
-      base::KeyboardCode win_keycode =
-          base::WindowsKeyCodeForGdkKeyCode(event->key.keyval);
+      app::KeyboardCode win_keycode =
+          app::WindowsKeyCodeForGdkKeyCode(event->key.keyval);
 
       if (!OnKeyDown(win_keycode))
         return false;
@@ -853,35 +853,35 @@ bool MenuController::OnKeyDown(int key_code
   DCHECK(blocking_run_);
 
   switch (key_code) {
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       IncrementSelection(-1);
       break;
 
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       IncrementSelection(1);
       break;
 
     // Handling of VK_RIGHT and VK_LEFT is different depending on the UI
     // layout.
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       if (base::i18n::IsRTL())
         CloseSubmenu();
       else
         OpenSubmenuChangeSelectionIfCan();
       break;
 
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       if (base::i18n::IsRTL())
         OpenSubmenuChangeSelectionIfCan();
       else
         CloseSubmenu();
       break;
 
-    case base::VKEY_SPACE:
+    case app::VKEY_SPACE:
       SendAcceleratorToHotTrackedView();
       break;
 
-    case base::VKEY_RETURN:
+    case app::VKEY_RETURN:
       if (pending_state_.item) {
         if (pending_state_.item->HasSubmenu()) {
           OpenSubmenuChangeSelectionIfCan();
@@ -893,7 +893,7 @@ bool MenuController::OnKeyDown(int key_code
       }
       break;
 
-    case base::VKEY_ESCAPE:
+    case app::VKEY_ESCAPE:
       if (!state_.item->GetParentMenuItem() ||
           (!state_.item->GetParentMenuItem()->GetParentMenuItem() &&
            (!state_.item->HasSubmenu() ||
@@ -956,7 +956,7 @@ bool MenuController::SendAcceleratorToHotTrackedView() {
   if (!hot_view)
     return false;
 
-  Accelerator accelerator(base::VKEY_RETURN, false, false, false);
+  Accelerator accelerator(app::VKEY_RETURN, false, false, false);
   hot_view->AcceleratorPressed(accelerator);
   hot_view->SetHotTracked(true);
   return true;
diff --git a/views/controls/menu/menu_win.cc b/views/controls/menu/menu_win.cc
index 90637a0..0c75743 100644
--- a/views/controls/menu/menu_win.cc
+++ b/views/controls/menu/menu_win.cc
@@ -6,9 +6,9 @@
 
 #include <string>
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
@@ -443,7 +443,7 @@ void MenuWin::AddMenuItemInternal(int index,
       delegate()->GetLabel(item_id) : label);
 
   // Find out if there is a shortcut we need to append to the label.
-  views::Accelerator accelerator(base::VKEY_UNKNOWN, false, false, false);
+  views::Accelerator accelerator(app::VKEY_UNKNOWN, false, false, false);
   if (delegate() && delegate()->GetAcceleratorInfo(item_id, &accelerator)) {
     actual_label += L'\t';
     actual_label += accelerator.GetShortcutText();
diff --git a/views/controls/menu/native_menu_gtk.cc b/views/controls/menu/native_menu_gtk.cc
index 2ddf336..7954d20 100644
--- a/views/controls/menu/native_menu_gtk.cc
+++ b/views/controls/menu/native_menu_gtk.cc
@@ -8,11 +8,11 @@
 #include <map>
 #include <string>
 
+#include "app/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_codes.h"
 #include "app/menus/menu_model.h"
 #include "base/gtk_util.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_code_conversion_gtk.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ -329,7 +329,7 @@ GtkWidget* NativeMenuGtk::AddMenuItemAt(int index,
                               submenu->GetNativeMenu());
   }
 
-  views::Accelerator accelerator(base::VKEY_UNKNOWN, false, false, false);
+  views::Accelerator accelerator(app::VKEY_UNKNOWN, false, false, false);
   if (accel_group && model_->GetAcceleratorAt(index, &accelerator)) {
     int gdk_modifiers = 0;
     if (accelerator.IsShiftDown())
@@ -339,7 +339,7 @@ GtkWidget* NativeMenuGtk::AddMenuItemAt(int index,
     if (accelerator.IsAltDown())
       gdk_modifiers |= GDK_MOD1_MASK;
     gtk_widget_add_accelerator(menu_item, "activate", accel_group,
-        base::GdkKeyCodeForWindowsKeyCode(accelerator.GetKeyCode(), false),
+        app::GdkKeyCodeForWindowsKeyCode(accelerator.GetKeyCode(), false),
         static_cast<GdkModifierType>(gdk_modifiers), GTK_ACCEL_VISIBLE);
   }
 
diff --git a/views/controls/menu/native_menu_win.cc b/views/controls/menu/native_menu_win.cc
index f65cfcd..665b15e 100644
--- a/views/controls/menu/native_menu_win.cc
+++ b/views/controls/menu/native_menu_win.cc
@@ -4,9 +4,9 @@
 
 #include "views/controls/menu/native_menu_win.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "gfx/canvas_skia.h"
@@ -554,7 +554,7 @@ void NativeMenuWin::UpdateMenuItemInfoForString(
   menus::MenuModel::ItemType type = model_->GetTypeAt(model_index);
   if (type != menus::MenuModel::TYPE_SUBMENU) {
     // Add accelerator details to the label if provided.
-    views::Accelerator accelerator(base::VKEY_UNKNOWN, false, false, false);
+    views::Accelerator accelerator(app::VKEY_UNKNOWN, false, false, false);
     if (model_->GetAcceleratorAt(model_index, &accelerator)) {
       formatted += L"\t";
       formatted += accelerator.GetShortcutText();
diff --git a/views/controls/native_control.cc b/views/controls/native_control.cc
index 942a093..a0ff1b0 100644
--- a/views/controls/native_control.cc
+++ b/views/controls/native_control.cc
@@ -10,8 +10,9 @@
 #include <atlframe.h>
 #include <atlmisc.h>
 
+#include "app/keyboard_code_conversion_win.h"
+#include "app/keyboard_codes.h"
 #include "app/l10n_util_win.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "gfx/native_theme_win.h"
@@ -359,7 +360,7 @@ LRESULT CALLBACK NativeControl::NativeControlWndProc(HWND window, UINT message,
   DCHECK(native_control);
 
   if (message == WM_KEYDOWN &&
-      native_control->OnKeyDown(win_util::WinToKeyboardCode(w_param))) {
+      native_control->OnKeyDown(app::KeyboardCodeForWindowsKeyCode(w_param))) {
     return 0;
   } else if (message == WM_SETFOCUS) {
     // Let the focus manager know that the focus changed.
diff --git a/views/controls/native_control.h b/views/controls/native_control.h
index a01ed83..5a180d2 100644
--- a/views/controls/native_control.h
+++ b/views/controls/native_control.h
@@ -8,7 +8,7 @@
 
 #include <windows.h>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "views/view.h"
 
 namespace views {
@@ -81,7 +81,7 @@ class NativeControl : public View {
 
   // Invoked when a key is pressed on the control.
   // Should return true if the key message was processed, false otherwise.
-  virtual bool OnKeyDown(base::KeyboardCode virtual_key_code) { return false; }
+  virtual bool OnKeyDown(app::KeyboardCode virtual_key_code) { return false; }
 
   // Returns additional extended style flags. When subclasses call
   // CreateWindowEx in order to create the underlying control, they must OR the
diff --git a/views/controls/scrollbar/bitmap_scroll_bar.cc b/views/controls/scrollbar/bitmap_scroll_bar.cc
index d5ac40c..d170b50 100644
--- a/views/controls/scrollbar/bitmap_scroll_bar.cc
+++ b/views/controls/scrollbar/bitmap_scroll_bar.cc
@@ -8,10 +8,10 @@
 #include "views/screen.h"
 #endif
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
-#include "base/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "gfx/canvas.h"
 #include "grit/app_strings.h"
@@ -496,32 +496,32 @@ bool BitmapScrollBar::OnMouseWheel(const MouseWheelEvent& event) {
 bool BitmapScrollBar::OnKeyPressed(const KeyEvent& event) {
   ScrollAmount amount = SCROLL_NONE;
   switch (event.GetKeyCode()) {
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       if (!IsHorizontal())
         amount = SCROLL_PREV_LINE;
       break;
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       if (!IsHorizontal())
         amount = SCROLL_NEXT_LINE;
       break;
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       if (IsHorizontal())
         amount = SCROLL_PREV_LINE;
       break;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       if (IsHorizontal())
         amount = SCROLL_NEXT_LINE;
       break;
-    case base::VKEY_PRIOR:
+    case app::VKEY_PRIOR:
       amount = SCROLL_PREV_PAGE;
       break;
-    case base::VKEY_NEXT:
+    case app::VKEY_NEXT:
       amount = SCROLL_NEXT_PAGE;
       break;
-    case base::VKEY_HOME:
+    case app::VKEY_HOME:
       amount = SCROLL_START;
       break;
-    case base::VKEY_END:
+    case app::VKEY_END:
       amount = SCROLL_END;
       break;
   }
diff --git a/views/controls/scrollbar/native_scroll_bar_gtk.cc b/views/controls/scrollbar/native_scroll_bar_gtk.cc
index c5d75c8..6f318ec 100644
--- a/views/controls/scrollbar/native_scroll_bar_gtk.cc
+++ b/views/controls/scrollbar/native_scroll_bar_gtk.cc
@@ -6,7 +6,7 @@
 
 #include <gtk/gtk.h>
 
-#include "base/keyboard_codes_posix.h"
+#include "app/keyboard_codes_posix.h"
 #include "views/controls/scrollbar/native_scroll_bar.h"
 #include "views/controls/scrollbar/scroll_bar.h"
 
@@ -45,32 +45,32 @@ bool NativeScrollBarGtk::OnKeyPressed(const KeyEvent& event) {
   if (!native_view())
     return false;
   switch (event.GetKeyCode()) {
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       if (!native_scroll_bar_->IsHorizontal())
         MoveStep(false /* negative */);
       break;
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       if (!native_scroll_bar_->IsHorizontal())
         MoveStep(true /* positive */);
       break;
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       if (native_scroll_bar_->IsHorizontal())
         MoveStep(false /* negative */);
       break;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       if (native_scroll_bar_->IsHorizontal())
         MoveStep(true /* positive */);
       break;
-    case base::VKEY_PRIOR:
+    case app::VKEY_PRIOR:
       MovePage(false /* negative */);
       break;
-    case base::VKEY_NEXT:
+    case app::VKEY_NEXT:
       MovePage(true /* positive */);
       break;
-    case base::VKEY_HOME:
+    case app::VKEY_HOME:
       MoveTo(0);
       break;
-    case base::VKEY_END:
+    case app::VKEY_END:
       MoveToBottom();
       break;
     default:
diff --git a/views/controls/scrollbar/native_scroll_bar_win.cc b/views/controls/scrollbar/native_scroll_bar_win.cc
index 65350e0..55592a8a 100644
--- a/views/controls/scrollbar/native_scroll_bar_win.cc
+++ b/views/controls/scrollbar/native_scroll_bar_win.cc
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <string>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "gfx/window_impl.h"
 #include "views/controls/scrollbar/native_scroll_bar.h"
@@ -231,31 +231,31 @@ bool NativeScrollBarWin::OnKeyPressed(const KeyEvent& event) {
     return false;
   int code = -1;
   switch (event.GetKeyCode()) {
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       if (!native_scroll_bar_->IsHorizontal())
         code = SB_LINEUP;
       break;
-    case base::VKEY_PRIOR:
+    case app::VKEY_PRIOR:
       code = SB_PAGEUP;
       break;
-    case base::VKEY_NEXT:
+    case app::VKEY_NEXT:
       code = SB_PAGEDOWN;
       break;
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       if (!native_scroll_bar_->IsHorizontal())
         code = SB_LINEDOWN;
       break;
-    case base::VKEY_HOME:
+    case app::VKEY_HOME:
       code = SB_TOP;
       break;
-    case base::VKEY_END:
+    case app::VKEY_END:
       code = SB_BOTTOM;
       break;
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       if (native_scroll_bar_->IsHorizontal())
         code = SB_LINELEFT;
       break;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       if (native_scroll_bar_->IsHorizontal())
         code = SB_LINERIGHT;
       break;
diff --git a/views/controls/tabbed_pane/tabbed_pane.cc b/views/controls/tabbed_pane/tabbed_pane.cc
index 110b134..8061821 100644
--- a/views/controls/tabbed_pane/tabbed_pane.cc
+++ b/views/controls/tabbed_pane/tabbed_pane.cc
@@ -4,7 +4,7 @@
 
 #include "views/controls/tabbed_pane/tabbed_pane.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "views/controls/native/native_view_host.h"
 #include "views/controls/tabbed_pane/native_tabbed_pane_wrapper.h"
@@ -82,7 +82,7 @@ void TabbedPane::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
 bool TabbedPane::AcceleratorPressed(const views::Accelerator& accelerator) {
   // We only accept Ctrl+Tab keyboard events.
   DCHECK(accelerator.GetKeyCode() ==
-      base::VKEY_TAB && accelerator.IsCtrlDown());
+      app::VKEY_TAB && accelerator.IsCtrlDown());
 
   int tab_count = GetTabCount();
   if (tab_count <= 1)
@@ -100,9 +100,9 @@ bool TabbedPane::AcceleratorPressed(const views::Accelerator& accelerator) {
 
 void TabbedPane::LoadAccelerators() {
   // Ctrl+Shift+Tab
-  AddAccelerator(views::Accelerator(base::VKEY_TAB, true, true, false));
+  AddAccelerator(views::Accelerator(app::VKEY_TAB, true, true, false));
   // Ctrl+Tab
-  AddAccelerator(views::Accelerator(base::VKEY_TAB, false, true, false));
+  AddAccelerator(views::Accelerator(app::VKEY_TAB, false, true, false));
 }
 
 void TabbedPane::Layout() {
diff --git a/views/controls/table/group_table_view.cc b/views/controls/table/group_table_view.cc
index 14a5eae..efef1a5 100644
--- a/views/controls/table/group_table_view.cc
+++ b/views/controls/table/group_table_view.cc
@@ -61,7 +61,7 @@ void GroupTableView::SyncSelection() {
   }
 }
 
-bool GroupTableView::OnKeyDown(base::KeyboardCode virtual_keycode) {
+bool GroupTableView::OnKeyDown(app::KeyboardCode virtual_keycode) {
   // In a list view, multiple items can be selected but only one item has the
   // focus. This creates a problem when the arrow keys are used for navigating
   // between items in the list view. An example will make this more clear:
@@ -87,8 +87,8 @@ bool GroupTableView::OnKeyDown(base::KeyboardCode virtual_keycode) {
   // detect that one of the arrow keys is pressed. Thus, when it comes time
   // for the list view control to actually switch the focus, the right item
   // will be selected.
-  if ((virtual_keycode != base::VKEY_UP) &&
-      (virtual_keycode != base::VKEY_DOWN)) {
+  if ((virtual_keycode != app::VKEY_UP) &&
+      (virtual_keycode != app::VKEY_DOWN)) {
     return TableView::OnKeyDown(virtual_keycode);
   }
 
@@ -116,10 +116,10 @@ bool GroupTableView::OnKeyDown(base::KeyboardCode virtual_keycode) {
   // If the user pressed the UP key, then the focus should be set to the
   // topmost element in the group. If the user pressed the DOWN key, the focus
   // should be set to the bottommost element.
-  if (virtual_keycode == base::VKEY_UP) {
+  if (virtual_keycode == app::VKEY_UP) {
     SetFocusOnItem(group_range.start);
   } else {
-    DCHECK_EQ(virtual_keycode, base::VKEY_DOWN);
+    DCHECK_EQ(virtual_keycode, app::VKEY_DOWN);
     SetFocusOnItem(group_range.start + group_range.length - 1);
   }
 
diff --git a/views/controls/table/group_table_view.h b/views/controls/table/group_table_view.h
index 0e9f1ee..d4853cb 100644
--- a/views/controls/table/group_table_view.h
+++ b/views/controls/table/group_table_view.h
@@ -56,7 +56,7 @@ class GroupTableView : public TableView {
   // keys), we must take action when an arrow key is pressed. The reason we
   // need to process this message has to do with the manner in which the focus
   // needs to be set on a group item when a group is selected.
-  virtual bool OnKeyDown(base::KeyboardCode virtual_keycode);
+  virtual bool OnKeyDown(app::KeyboardCode virtual_keycode);
 
   // Overriden to make sure rows in the same group stay grouped together.
   virtual int CompareRows(int model_row1, int model_row2);
diff --git a/views/controls/table/native_table_win.cc b/views/controls/table/native_table_win.cc
index f0b0659..82561e1 100644
--- a/views/controls/table/native_table_win.cc
+++ b/views/controls/table/native_table_win.cc
@@ -463,7 +463,7 @@ void NativeTableWin::OnMiddleClick() {
     table_->observer()->OnMiddleClick();
 }
 
-bool NativeTableWin::OnKeyDown(base::KeyboardCode virtual_keycode) {
+bool NativeTableWin::OnKeyDown(app::KeyboardCode virtual_keycode) {
   if (!ignore_listview_change_ && table_->observer())
     table_->observer()->OnKeyDown(virtual_keycode);
   return false;  // Let the key event be processed as ususal.
diff --git a/views/controls/table/native_table_win.h b/views/controls/table/native_table_win.h
index d23a961..dcbc087 100644
--- a/views/controls/table/native_table_win.h
+++ b/views/controls/table/native_table_win.h
@@ -74,7 +74,7 @@ class NativeTableWin : public NativeControlWin, public NativeTableWrapper {
   virtual void OnMiddleClick();
 
   // Overridden from NativeControl. Notifies the observer.
-  virtual bool OnKeyDown(base::KeyboardCode virtual_keycode);
+  virtual bool OnKeyDown(app::KeyboardCode virtual_keycode);
 
   // Custom drawing of our icons.
   LRESULT OnCustomDraw(NMLVCUSTOMDRAW* draw_info);
diff --git a/views/controls/table/table_view.cc b/views/controls/table/table_view.cc
index 510d536..e397ce9 100644
--- a/views/controls/table/table_view.cc
+++ b/views/controls/table/table_view.cc
@@ -1488,7 +1488,7 @@ void TableView::OnSelectedStateChanged() {
   }
 }
 
-bool TableView::OnKeyDown(base::KeyboardCode virtual_keycode) {
+bool TableView::OnKeyDown(app::KeyboardCode virtual_keycode) {
   if (!ignore_listview_change_ && table_view_observer_) {
     table_view_observer_->OnKeyDown(virtual_keycode);
   }
diff --git a/views/controls/table/table_view.h b/views/controls/table/table_view.h
index 2799c62..9444d96b 100644
--- a/views/controls/table/table_view.h
+++ b/views/controls/table/table_view.h
@@ -16,8 +16,8 @@ typedef struct tagNMLVCUSTOMDRAW NMLVCUSTOMDRAW;
 #include <map>
 #include <vector>
 
+#include "app/keyboard_codes.h"
 #include "app/table_model_observer.h"
-#include "base/keyboard_codes.h"
 #include "third_party/skia/include/core/SkColor.h"
 #if defined(OS_WIN)
 // TODO(port): remove the ifdef when native_control.h is ported.
@@ -257,7 +257,7 @@ class TableView : public NativeControl,
   virtual void OnMiddleClick();
 
   // Overridden from NativeControl. Notifies the observer.
-  virtual bool OnKeyDown(base::KeyboardCode virtual_keycode);
+  virtual bool OnKeyDown(app::KeyboardCode virtual_keycode);
 
   // Invoked to customize the colors or font at a particular cell. If you
   // change the colors or font, return true. This is only invoked if
diff --git a/views/controls/table/table_view_observer.h b/views/controls/table/table_view_observer.h
index 07a1e86..86fff7a 100644
--- a/views/controls/table/table_view_observer.h
+++ b/views/controls/table/table_view_observer.h
@@ -6,7 +6,7 @@
 #define VIEWS_CONTROLS_TABLE_TABLE_VIEW_OBSERVER_H_
 #pragma once
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 
 namespace views {
 
@@ -28,7 +28,7 @@ class TableViewObserver {
   virtual void OnMiddleClick() {}
 
   // Optional method invoked when the user hits a key with the table in focus.
-  virtual void OnKeyDown(base::KeyboardCode virtual_keycode) {}
+  virtual void OnKeyDown(app::KeyboardCode virtual_keycode) {}
 
   // Invoked when the user presses the delete key.
   virtual void OnTableViewDelete(TableView* table_view) {}
diff --git a/views/controls/textfield/native_textfield_win.cc b/views/controls/textfield/native_textfield_win.cc
index fc4ad8b..c91dcdf 100644
--- a/views/controls/textfield/native_textfield_win.cc
+++ b/views/controls/textfield/native_textfield_win.cc
@@ -8,11 +8,11 @@
 
 #include "app/clipboard/clipboard.h"
 #include "app/clipboard/scoped_clipboard_writer.h"
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/win_util.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_codes.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win_util.h"
@@ -313,13 +313,13 @@ bool NativeTextfieldWin::GetAcceleratorForCommandId(int command_id,
   // anywhere so we need to check for them explicitly here.
   switch (command_id) {
     case IDS_APP_CUT:
-      *accelerator = views::Accelerator(base::VKEY_X, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_X, false, true, false);
       return true;
     case IDS_APP_COPY:
-      *accelerator = views::Accelerator(base::VKEY_C, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_C, false, true, false);
       return true;
     case IDS_APP_PASTE:
-      *accelerator = views::Accelerator(base::VKEY_V, false, true, false);
+      *accelerator = views::Accelerator(app::VKEY_V, false, true, false);
       return true;
   }
   return container_view_->GetWidget()->GetAccelerator(command_id, accelerator);
@@ -868,7 +868,7 @@ void NativeTextfieldWin::HandleKeystroke(UINT message,
   if (!handled) {
     OnBeforePossibleChange();
 
-    if (key == base::VKEY_HOME || key == base::VKEY_END) {
+    if (key == app::VKEY_HOME || key == app::VKEY_END) {
       // DefWindowProc() might reset the keyboard layout when it receives a
       // keydown event for VKEY_HOME or VKEY_END. When the window was created
       // with WS_EX_LAYOUTRTL and the current keyboard layout is not a RTL one,
diff --git a/views/controls/textfield/textfield.cc b/views/controls/textfield/textfield.cc
index 43f0897..fc8d081 100644
--- a/views/controls/textfield/textfield.cc
+++ b/views/controls/textfield/textfield.cc
@@ -10,7 +10,7 @@
 
 #include <string>
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/insets.h"
@@ -19,7 +19,7 @@
 #include "views/widget/widget.h"
 
 #if defined(OS_LINUX)
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 #elif defined(OS_WIN)
 #include "app/win_util.h"
 #include "base/win_util.h"
@@ -239,14 +239,14 @@ void Textfield::AboutToRequestFocusFromTabTraversal(bool reverse) {
 bool Textfield::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
   // TODO(hamaji): Figure out which keyboard combinations we need to add here,
   //               similar to LocationBarView::SkipDefaultKeyEventProcessing.
-  base::KeyboardCode key = e.GetKeyCode();
-  if (key == base::VKEY_BACK)
+  app::KeyboardCode key = e.GetKeyCode();
+  if (key == app::VKEY_BACK)
     return true;  // We'll handle BackSpace ourselves.
 
 #if defined(OS_WIN)
   // We don't translate accelerators for ALT + NumPad digit on Windows, they are
   // used for entering special characters.  We do translate alt-home.
-  if (e.IsAltDown() && (key != base::VKEY_HOME) &&
+  if (e.IsAltDown() && (key != app::VKEY_HOME) &&
       win_util::IsNumPadDigit(key, e.IsExtendedKey()))
     return true;
 #endif
@@ -332,12 +332,12 @@ std::string Textfield::GetClassName() const {
   return kViewClassName;
 }
 
-base::KeyboardCode Textfield::Keystroke::GetKeyboardCode() const {
+app::KeyboardCode Textfield::Keystroke::GetKeyboardCode() const {
 #if defined(OS_WIN)
-  return static_cast<base::KeyboardCode>(key_);
+  return static_cast<app::KeyboardCode>(key_);
 #else
-  return static_cast<base::KeyboardCode>(
-      base::WindowsKeyCodeForGdkKeyCode(event_.keyval));
+  return static_cast<app::KeyboardCode>(
+      app::WindowsKeyCodeForGdkKeyCode(event_.keyval));
 #endif
 }
 
diff --git a/views/controls/textfield/textfield.h b/views/controls/textfield/textfield.h
index 564243e..3bd6c31 100644
--- a/views/controls/textfield/textfield.h
+++ b/views/controls/textfield/textfield.h
@@ -14,8 +14,8 @@
 
 #include <string>
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #if !defined(OS_LINUX)
 #include "base/logging.h"
 #endif
@@ -65,7 +65,7 @@ class Textfield : public View {
     }
     const GdkEventKey* event() const { return &event_; }
 #endif
-    base::KeyboardCode GetKeyboardCode() const;
+    app::KeyboardCode GetKeyboardCode() const;
     bool IsControlHeld() const;
     bool IsShiftHeld() const;
 
diff --git a/views/controls/tree/tree_view.cc b/views/controls/tree/tree_view.cc
index eba1a31..27edeaf 100644
--- a/views/controls/tree/tree_view.cc
+++ b/views/controls/tree/tree_view.cc
@@ -6,10 +6,11 @@
 
 #include <vector>
 
+#include "app/keyboard_code_conversion_win.h"
+#include "app/keyboard_codes.h"
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/win_util.h"
@@ -448,7 +449,7 @@ LRESULT TreeView::OnNotify(int w_param, LPNMHDR l_param) {
         NMTVKEYDOWN* key_down_message =
             reinterpret_cast<NMTVKEYDOWN*>(l_param);
         controller_->OnTreeViewKeyDown(
-            win_util::WinToKeyboardCode(key_down_message->wVKey));
+            app::KeyboardCodeForWindowsKeyCode(key_down_message->wVKey));
       }
       break;
 
@@ -458,7 +459,7 @@ LRESULT TreeView::OnNotify(int w_param, LPNMHDR l_param) {
   return 0;
 }
 
-bool TreeView::OnKeyDown(base::KeyboardCode virtual_key_code) {
+bool TreeView::OnKeyDown(app::KeyboardCode virtual_key_code) {
   if (virtual_key_code == VK_F2) {
     if (!GetEditingNode()) {
       TreeModelNode* selected_node = GetSelectedNode();
@@ -466,7 +467,7 @@ bool TreeView::OnKeyDown(base::KeyboardCode virtual_key_code) {
         StartEditing(selected_node);
     }
     return true;
-  } else if (virtual_key_code == base::VKEY_RETURN && !process_enter_) {
+  } else if (virtual_key_code == app::VKEY_RETURN && !process_enter_) {
     Widget* widget = GetWidget();
     DCHECK(widget);
     Accelerator accelerator(Accelerator(virtual_key_code,
diff --git a/views/controls/tree/tree_view.h b/views/controls/tree/tree_view.h
index cbcfbe7..593219c 100644
--- a/views/controls/tree/tree_view.h
+++ b/views/controls/tree/tree_view.h
@@ -11,9 +11,9 @@
 
 #include <map>
 
+#include "app/keyboard_codes.h"
 #include "app/tree_model.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "views/controls/native_control.h"
 
 namespace views {
@@ -36,7 +36,7 @@ class TreeViewController {
   }
 
   // Invoked when a key is pressed on the tree view.
-  virtual void OnTreeViewKeyDown(base::KeyboardCode keycode) {}
+  virtual void OnTreeViewKeyDown(app::KeyboardCode keycode) {}
 };
 
 // TreeView -------------------------------------------------------------------
@@ -181,7 +181,7 @@ class TreeView : public NativeControl, TreeModelObserver {
   // We pay attention to key down for two reasons: to circumvent VK_ENTER from
   // toggling the expaned state when processes_enter_ is false, and to have F2
   // start editting.
-  virtual bool OnKeyDown(base::KeyboardCode virtual_key_code);
+  virtual bool OnKeyDown(app::KeyboardCode virtual_key_code);
 
   virtual void OnContextMenu(const POINT& location);
 
diff --git a/views/event.cc b/views/event.cc
index ba05875..e047004 100644
--- a/views/event.cc
+++ b/views/event.cc
@@ -25,7 +25,7 @@ LocatedEvent::LocatedEvent(const LocatedEvent& model, View* from, View* to)
     View::ConvertPointToView(from, to, &location_);
 }
 
-KeyEvent::KeyEvent(EventType type, base::KeyboardCode key_code,
+KeyEvent::KeyEvent(EventType type, app::KeyboardCode key_code,
                    int event_flags, int repeat_count, int message_flags)
     : Event(type, event_flags),
       key_code_(key_code),
diff --git a/views/event.h b/views/event.h
index aa1905c..14a6af7 100644
--- a/views/event.h
+++ b/views/event.h
@@ -6,8 +6,8 @@
 #define VIEWS_EVENT_H_
 #pragma once
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "gfx/point.h"
 
 #if defined(OS_LINUX)
@@ -309,7 +309,7 @@ class KeyEvent : public Event {
  public:
   // Create a new key event
   KeyEvent(EventType type,
-           base::KeyboardCode key_code,
+           app::KeyboardCode key_code,
            int event_flags,
            int repeat_count,
            int message_flags);
@@ -317,11 +317,11 @@ class KeyEvent : public Event {
   explicit KeyEvent(GdkEventKey* event);
 #endif
 
-  // This returns a VKEY_ value as defined in base/keyboard_codes.h which is
+  // This returns a VKEY_ value as defined in app/keyboard_codes.h which is
   // the Windows value.
   // On GTK, you can use the methods in keyboard_code_conversion_gtk.cc to
   // convert this value back to a GDK value if needed.
-  base::KeyboardCode GetKeyCode() const {
+  app::KeyboardCode GetKeyCode() const {
     return key_code_;
   }
 
@@ -340,7 +340,7 @@ class KeyEvent : public Event {
 
  private:
 
-  base::KeyboardCode key_code_;
+  app::KeyboardCode key_code_;
   int repeat_count_;
   int message_flags_;
 
diff --git a/views/event_gtk.cc b/views/event_gtk.cc
index cb76e76..6ffd449 100644
--- a/views/event_gtk.cc
+++ b/views/event_gtk.cc
@@ -6,7 +6,7 @@
 
 #include <gdk/gdk.h>
 
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 
 namespace views {
 
@@ -15,7 +15,7 @@ KeyEvent::KeyEvent(GdkEventKey* event)
             Event::ET_KEY_PRESSED : Event::ET_KEY_RELEASED,
             GetFlagsFromGdkState(event->state)),
       // TODO(erg): All these values are iffy.
-      key_code_(base::WindowsKeyCodeForGdkKeyCode(event->keyval)),
+      key_code_(app::WindowsKeyCodeForGdkKeyCode(event->keyval)),
       repeat_count_(0),
       message_flags_(0) {
 }
diff --git a/views/examples/table2_example.h b/views/examples/table2_example.h
index 9e2f22f..c58b073 100644
--- a/views/examples/table2_example.h
+++ b/views/examples/table2_example.h
@@ -130,7 +130,7 @@ class Table2Example
 
   virtual void OnMiddleClick() {}
 
-  virtual void OnKeyDown(base::KeyboardCode virtual_keycode) {}
+  virtual void OnKeyDown(app::KeyboardCode virtual_keycode) {}
 
   virtual void OnTableViewDelete(views::TableView* table_view) {}
 
diff --git a/views/examples/table_example.h b/views/examples/table_example.h
index 1a447f4..c71b2c8 100644
--- a/views/examples/table_example.h
+++ b/views/examples/table_example.h
@@ -124,7 +124,7 @@ class TableExample
 
   virtual void OnMiddleClick() {}
 
-  virtual void OnKeyDown(base::KeyboardCode virtual_keycode) {}
+  virtual void OnKeyDown(app::KeyboardCode virtual_keycode) {}
 
   virtual void OnTableViewDelete(views::TableView* table_view) {}
 
diff --git a/views/focus/accelerator_handler_gtk_unittest.cc b/views/focus/accelerator_handler_gtk_unittest.cc
index 78e9110..baa11bc 100644
--- a/views/focus/accelerator_handler_gtk_unittest.cc
+++ b/views/focus/accelerator_handler_gtk_unittest.cc
@@ -19,8 +19,8 @@ class AcceleratorHandlerGtkTest
       public AcceleratorTarget {
  public:
   AcceleratorHandlerGtkTest()
-      : kMenuAccelerator(base::VKEY_MENU, false, false, false),
-        kHomepageAccelerator(base::VKEY_HOME, false, false, true),
+      : kMenuAccelerator(app::VKEY_MENU, false, false, false),
+        kHomepageAccelerator(app::VKEY_HOME, false, false, true),
         content_view_(NULL) {
   }
 
diff --git a/views/focus/accelerator_handler_win.cc b/views/focus/accelerator_handler_win.cc
index 64b51f4..496acd4 100644
--- a/views/focus/accelerator_handler_win.cc
+++ b/views/focus/accelerator_handler_win.cc
@@ -4,7 +4,8 @@
 
 #include "views/focus/accelerator_handler.h"
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_code_conversion_win.h"
+#include "app/keyboard_codes.h"
 #include "base/win_util.h"
 #include "views/event.h"
 #include "views/focus/focus_manager.h"
@@ -25,7 +26,7 @@ bool AcceleratorHandler::Dispatch(const MSG& msg) {
         case WM_KEYDOWN:
         case WM_SYSKEYDOWN: {
           KeyEvent event(Event::ET_KEY_PRESSED,
-                         win_util::WinToKeyboardCode(msg.wParam),
+                         app::KeyboardCodeForWindowsKeyCode(msg.wParam),
                          KeyEvent::GetKeyStateFlags(),
                          msg.lParam & 0xFFFF,
                          (msg.lParam & 0xFFFF0000) >> 16);
diff --git a/views/focus/focus_manager.cc b/views/focus/focus_manager.cc
index f0f5f99..3751ace 100644
--- a/views/focus/focus_manager.cc
+++ b/views/focus/focus_manager.cc
@@ -12,7 +12,7 @@
 #include <gtk/gtk.h>
 #endif
 
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "views/accelerator.h"
 #include "views/focus/focus_search.h"
@@ -109,11 +109,11 @@ bool FocusManager::OnKeyEvent(const KeyEvent& event) {
 #endif
 
   // Intercept arrow key messages to switch between grouped views.
-  base::KeyboardCode key_code = event.GetKeyCode();
+  app::KeyboardCode key_code = event.GetKeyCode();
   if (focused_view_ && focused_view_->GetGroup() != -1 &&
-      (key_code == base::VKEY_UP || key_code == base::VKEY_DOWN ||
-       key_code == base::VKEY_LEFT || key_code == base::VKEY_RIGHT)) {
-    bool next = (key_code == base::VKEY_RIGHT || key_code == base::VKEY_DOWN);
+      (key_code == app::VKEY_UP || key_code == app::VKEY_DOWN ||
+       key_code == app::VKEY_LEFT || key_code == app::VKEY_RIGHT)) {
+    bool next = (key_code == app::VKEY_RIGHT || key_code == app::VKEY_DOWN);
     std::vector<View*> views;
     focused_view_->GetParent()->GetViewsWithGroup(focused_view_->GetGroup(),
                                                   &views);
@@ -494,7 +494,7 @@ AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
 
 // static
 bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
-  return key_event.GetKeyCode() == base::VKEY_TAB &&
+  return key_event.GetKeyCode() == app::VKEY_TAB &&
          !key_event.IsControlDown();
 }
 
diff --git a/views/focus/focus_manager_unittest.cc b/views/focus/focus_manager_unittest.cc
index a711538..c7a3cf4 100644
--- a/views/focus/focus_manager_unittest.cc
+++ b/views/focus/focus_manager_unittest.cc
@@ -5,7 +5,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "app/combobox_model.h"
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
@@ -36,7 +36,7 @@
 #include "views/widget/widget_win.h"
 #include "views/window/window_win.h"
 #elif defined(OS_LINUX)
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 #include "views/window/window_gtk.h"
 #endif
 
@@ -209,23 +209,23 @@ class FocusManagerTest : public testing::Test, public WindowDelegate {
   }
 
 #if defined(OS_WIN)
-  void PostKeyDown(base::KeyboardCode key_code) {
+  void PostKeyDown(app::KeyboardCode key_code) {
     ::PostMessage(window_->GetNativeWindow(), WM_KEYDOWN, key_code, 0);
   }
 
-  void PostKeyUp(base::KeyboardCode key_code) {
+  void PostKeyUp(app::KeyboardCode key_code) {
     ::PostMessage(window_->GetNativeWindow(), WM_KEYUP, key_code, 0);
   }
 #elif defined(OS_LINUX)
-  void PostKeyDown(base::KeyboardCode key_code) {
+  void PostKeyDown(app::KeyboardCode key_code) {
     PostKeyEvent(key_code, true);
   }
 
-  void PostKeyUp(base::KeyboardCode key_code) {
+  void PostKeyUp(app::KeyboardCode key_code) {
     PostKeyEvent(key_code, false);
   }
 
-  void PostKeyEvent(base::KeyboardCode key_code, bool pressed) {
+  void PostKeyEvent(app::KeyboardCode key_code, bool pressed) {
     int keyval = GdkKeyCodeForWindowsKeyCode(key_code, false);
     GdkKeymapKey* keys;
     gint n_keys;
@@ -1300,8 +1300,8 @@ class TestAcceleratorTarget : public AcceleratorTarget {
 
 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
-  Accelerator escape_accelerator(base::VKEY_ESCAPE, false, false, false);
+  Accelerator return_accelerator(app::VKEY_RETURN, false, false, false);
+  Accelerator escape_accelerator(app::VKEY_ESCAPE, false, false, false);
 
   TestAcceleratorTarget return_target(true);
   TestAcceleratorTarget escape_target(true);
@@ -1418,7 +1418,7 @@ class SelfUnregisteringAcceleratorTarget : public AcceleratorTarget {
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
+  Accelerator return_accelerator(app::VKEY_RETURN, false, false, false);
   SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager);
   EXPECT_EQ(target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
@@ -1466,11 +1466,11 @@ class MessageTrackingView : public View {
     keys_released_.clear();
   }
 
-  const std::vector<base::KeyboardCode>& keys_pressed() const {
+  const std::vector<app::KeyboardCode>& keys_pressed() const {
     return keys_pressed_;
   }
 
-  const std::vector<base::KeyboardCode>& keys_released() const {
+  const std::vector<app::KeyboardCode>& keys_released() const {
     return keys_released_;
   }
 
@@ -1480,8 +1480,8 @@ class MessageTrackingView : public View {
 
  private:
   bool accelerator_pressed_;
-  std::vector<base::KeyboardCode> keys_pressed_;
-  std::vector<base::KeyboardCode> keys_released_;
+  std::vector<app::KeyboardCode> keys_pressed_;
+  std::vector<app::KeyboardCode> keys_released_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageTrackingView);
 };
@@ -1494,53 +1494,53 @@ class MessageTrackingView : public View {
 TEST_F(FocusManagerTest, IgnoreKeyupForAccelerators) {
   FocusManager* focus_manager = GetFocusManager();
   MessageTrackingView* mtv = new MessageTrackingView();
-  mtv->AddAccelerator(Accelerator(base::VKEY_0, false, false, false));
-  mtv->AddAccelerator(Accelerator(base::VKEY_1, false, false, false));
+  mtv->AddAccelerator(Accelerator(app::VKEY_0, false, false, false));
+  mtv->AddAccelerator(Accelerator(app::VKEY_1, false, false, false));
   content_view_->AddChildView(mtv);
   focus_manager->SetFocusedView(mtv);
 
   // First send a non-accelerator key sequence.
-  PostKeyDown(base::VKEY_9);
-  PostKeyUp(base::VKEY_9);
+  PostKeyDown(app::VKEY_9);
+  PostKeyUp(app::VKEY_9);
   AcceleratorHandler accelerator_handler;
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   // Make sure we get a key-up and key-down.
   ASSERT_EQ(1U, mtv->keys_pressed().size());
-  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(0));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(0));
   ASSERT_EQ(1U, mtv->keys_released().size());
-  EXPECT_EQ(base::VKEY_9, mtv->keys_released().at(0));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_released().at(0));
   EXPECT_FALSE(mtv->accelerator_pressed());
   mtv->Reset();
 
   // Same thing with repeat and more than one key at once.
-  PostKeyDown(base::VKEY_9);
-  PostKeyDown(base::VKEY_9);
-  PostKeyDown(base::VKEY_8);
-  PostKeyDown(base::VKEY_9);
-  PostKeyDown(base::VKEY_7);
-  PostKeyUp(base::VKEY_9);
-  PostKeyUp(base::VKEY_7);
-  PostKeyUp(base::VKEY_8);
+  PostKeyDown(app::VKEY_9);
+  PostKeyDown(app::VKEY_9);
+  PostKeyDown(app::VKEY_8);
+  PostKeyDown(app::VKEY_9);
+  PostKeyDown(app::VKEY_7);
+  PostKeyUp(app::VKEY_9);
+  PostKeyUp(app::VKEY_7);
+  PostKeyUp(app::VKEY_8);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   // Make sure we get a key-up and key-down.
   ASSERT_EQ(5U, mtv->keys_pressed().size());
-  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(0));
-  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(1));
-  EXPECT_EQ(base::VKEY_8, mtv->keys_pressed().at(2));
-  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(3));
-  EXPECT_EQ(base::VKEY_7, mtv->keys_pressed().at(4));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(0));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(1));
+  EXPECT_EQ(app::VKEY_8, mtv->keys_pressed().at(2));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(3));
+  EXPECT_EQ(app::VKEY_7, mtv->keys_pressed().at(4));
   ASSERT_EQ(3U, mtv->keys_released().size());
-  EXPECT_EQ(base::VKEY_9, mtv->keys_released().at(0));
-  EXPECT_EQ(base::VKEY_7, mtv->keys_released().at(1));
-  EXPECT_EQ(base::VKEY_8, mtv->keys_released().at(2));
+  EXPECT_EQ(app::VKEY_9, mtv->keys_released().at(0));
+  EXPECT_EQ(app::VKEY_7, mtv->keys_released().at(1));
+  EXPECT_EQ(app::VKEY_8, mtv->keys_released().at(2));
   EXPECT_FALSE(mtv->accelerator_pressed());
   mtv->Reset();
 
   // Now send an accelerator key sequence.
-  PostKeyDown(base::VKEY_0);
-  PostKeyUp(base::VKEY_0);
+  PostKeyDown(app::VKEY_0);
+  PostKeyUp(app::VKEY_0);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   EXPECT_TRUE(mtv->keys_pressed().empty());
@@ -1549,13 +1549,13 @@ TEST_F(FocusManagerTest, IgnoreKeyupForAccelerators) {
   mtv->Reset();
 
   // Same thing with repeat and more than one key at once.
-  PostKeyDown(base::VKEY_0);
-  PostKeyDown(base::VKEY_1);
-  PostKeyDown(base::VKEY_1);
-  PostKeyDown(base::VKEY_0);
-  PostKeyDown(base::VKEY_0);
-  PostKeyUp(base::VKEY_1);
-  PostKeyUp(base::VKEY_0);
+  PostKeyDown(app::VKEY_0);
+  PostKeyDown(app::VKEY_1);
+  PostKeyDown(app::VKEY_1);
+  PostKeyDown(app::VKEY_0);
+  PostKeyDown(app::VKEY_0);
+  PostKeyUp(app::VKEY_1);
+  PostKeyUp(app::VKEY_0);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   EXPECT_TRUE(mtv->keys_pressed().empty());
diff --git a/views/view_unittest.cc b/views/view_unittest.cc
index 870273e..a44ce6f 100644
--- a/views/view_unittest.cc
+++ b/views/view_unittest.cc
@@ -5,7 +5,7 @@
 #include <map>
 
 #include "app/clipboard/clipboard.h"
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ -828,7 +828,7 @@ bool TestView::AcceleratorPressed(const Accelerator& accelerator) {
 #if defined(OS_WIN)
 TEST_F(ViewTest, ActivateAccelerator) {
   // Register a keyboard accelerator before the view is added to a window.
-  views::Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
+  views::Accelerator return_accelerator(app::VKEY_RETURN, false, false, false);
   TestView* view = new TestView();
   view->Reset();
   view->AddAccelerator(return_accelerator);
@@ -852,7 +852,7 @@ TEST_F(ViewTest, ActivateAccelerator) {
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 1);
 
   // Hit the escape key. Nothing should happen.
-  views::Accelerator escape_accelerator(base::VKEY_ESCAPE, false, false, false);
+  views::Accelerator escape_accelerator(app::VKEY_ESCAPE, false, false, false);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(view->accelerator_count_map_[return_accelerator], 1);
   EXPECT_EQ(view->accelerator_count_map_[escape_accelerator], 0);
@@ -1108,7 +1108,7 @@ class DefaultButtonTest : public ViewTest {
   }
 
   void SimularePressingEnterAndCheckDefaultButton(ButtonID button_id) {
-    KeyEvent event(Event::ET_KEY_PRESSED, base::VKEY_RETURN, 0, 0, 0);
+    KeyEvent event(Event::ET_KEY_PRESSED, app::VKEY_RETURN, 0, 0, 0);
     focus_manager_->OnKeyEvent(event);
     switch (button_id) {
       case OK:
diff --git a/views/widget/root_view.cc b/views/widget/root_view.cc
index a56ec99..20464cc 100644
--- a/views/widget/root_view.cc
+++ b/views/widget/root_view.cc
@@ -7,7 +7,7 @@
 #include <algorithm>
 
 #include "app/drag_drop_types.h"
-#include "base/keyboard_codes.h"
+#include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "gfx/canvas_skia.h"
@@ -581,8 +581,8 @@ bool RootView::ProcessKeyEvent(const KeyEvent& event) {
   View* v = GetFocusedView();
   // Special case to handle right-click context menus triggered by the
   // keyboard.
-  if (v && v->IsEnabled() && ((event.GetKeyCode() == base::VKEY_APPS) ||
-     (event.GetKeyCode() == base::VKEY_F10 && event.IsShiftDown()))) {
+  if (v && v->IsEnabled() && ((event.GetKeyCode() == app::VKEY_APPS) ||
+     (event.GetKeyCode() == app::VKEY_F10 && event.IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
     return true;
   }
diff --git a/views/widget/widget_gtk.cc b/views/widget/widget_gtk.cc
index 0a129f6..67d542f 100644
--- a/views/widget/widget_gtk.cc
+++ b/views/widget/widget_gtk.cc
@@ -884,21 +884,21 @@ bool WidgetGtk::HandleKeyboardEvent(GdkEventKey* event) {
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an unhandled VKEY_MENU key press event.
-  if (key_code != base::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+  if (key_code != app::VKEY_MENU || event->type != GDK_KEY_RELEASE)
     should_handle_menu_key_release_ = false;
 
   if (event->type == GDK_KEY_PRESS) {
     // VKEY_MENU is triggered by key release event.
     // FocusManager::OnKeyEvent() returns false when the key has been consumed.
-    if (key_code != base::VKEY_MENU)
+    if (key_code != app::VKEY_MENU)
       handled = !focus_manager_->OnKeyEvent(key);
     else
       should_handle_menu_key_release_ = true;
-  } else if (key_code == base::VKEY_MENU && should_handle_menu_key_release_ &&
+  } else if (key_code == app::VKEY_MENU && should_handle_menu_key_release_ &&
              (key.GetFlags() & ~Event::EF_ALT_DOWN) == 0) {
     // Trigger VKEY_MENU when only this key is pressed and released, and both
     // press and release events are not handled by others.
-    Accelerator accelerator(base::VKEY_MENU, false, false, false);
+    Accelerator accelerator(app::VKEY_MENU, false, false, false);
     handled = focus_manager_->ProcessAccelerator(accelerator);
   }
 
@@ -1167,7 +1167,7 @@ gboolean WidgetGtk::OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
-  if (key.GetKeyCode() != base::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+  if (key.GetKeyCode() != app::VKEY_MENU || event->type != GDK_KEY_RELEASE)
     should_handle_menu_key_release_ = false;
 
   bool handled = false;
diff --git a/views/widget/widget_win.cc b/views/widget/widget_win.cc
index f11031c..ec0121a 100644
--- a/views/widget/widget_win.cc
+++ b/views/widget/widget_win.cc
@@ -4,6 +4,7 @@
 
 #include "views/widget/widget_win.h"
 
+#include "app/keyboard_code_conversion_win.h"
 #include "app/l10n_util_win.h"
 #include "app/system_monitor.h"
 #include "app/win_util.h"
@@ -672,7 +673,7 @@ void WidgetWin::OnInitMenuPopup(HMENU menu,
 }
 
 void WidgetWin::OnKeyDown(TCHAR c, UINT rep_cnt, UINT flags) {
-  KeyEvent event(Event::ET_KEY_PRESSED, win_util::WinToKeyboardCode(c),
+  KeyEvent event(Event::ET_KEY_PRESSED, app::KeyboardCodeForWindowsKeyCode(c),
                  KeyEvent::GetKeyStateFlags(), rep_cnt, flags);
   RootView* root_view = GetFocusedViewRootView();
   if (!root_view)
@@ -682,7 +683,7 @@ void WidgetWin::OnKeyDown(TCHAR c, UINT rep_cnt, UINT flags) {
 }
 
 void WidgetWin::OnKeyUp(TCHAR c, UINT rep_cnt, UINT flags) {
-  KeyEvent event(Event::ET_KEY_RELEASED, win_util::WinToKeyboardCode(c),
+  KeyEvent event(Event::ET_KEY_RELEASED, app::KeyboardCodeForWindowsKeyCode(c),
                  KeyEvent::GetKeyStateFlags(), rep_cnt, flags);
   RootView* root_view = GetFocusedViewRootView();
   if (!root_view)
diff --git a/views/window/dialog_client_view.cc b/views/window/dialog_client_view.cc
index bbc7672..9dd45ac 100644
--- a/views/window/dialog_client_view.cc
+++ b/views/window/dialog_client_view.cc
@@ -14,9 +14,9 @@
 
 #include <algorithm>
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
-#include "base/keyboard_codes.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/font.h"
 #include "grit/app_strings.h"
@@ -139,7 +139,7 @@ void DialogClientView::ShowDialogButtons() {
     if (is_default_button)
       default_button_ = ok_button_;
     if (!(buttons & MessageBoxFlags::DIALOGBUTTON_CANCEL))
-      ok_button_->AddAccelerator(Accelerator(base::VKEY_ESCAPE,
+      ok_button_->AddAccelerator(Accelerator(app::VKEY_ESCAPE,
                                              false, false, false));
     AddChildView(ok_button_);
   }
@@ -160,7 +160,7 @@ void DialogClientView::ShowDialogButtons() {
                                       MessageBoxFlags::DIALOGBUTTON_CANCEL,
                                       label, is_default_button);
     cancel_button_->SetGroup(kButtonGroup);
-    cancel_button_->AddAccelerator(Accelerator(base::VKEY_ESCAPE,
+    cancel_button_->AddAccelerator(Accelerator(app::VKEY_ESCAPE,
                                                false, false, false));
     if (is_default_button)
       default_button_ = ok_button_;
@@ -169,7 +169,7 @@ void DialogClientView::ShowDialogButtons() {
   if (!buttons) {
     // Register the escape key as an accelerator which will close the window
     // if there are no dialog buttons.
-    AddAccelerator(Accelerator(base::VKEY_ESCAPE, false, false, false));
+    AddAccelerator(Accelerator(app::VKEY_ESCAPE, false, false, false));
   }
 }
 
@@ -387,7 +387,7 @@ gfx::Size DialogClientView::GetPreferredSize() {
 
 bool DialogClientView::AcceleratorPressed(const Accelerator& accelerator) {
   // We only expect Escape key.
-  DCHECK(accelerator.GetKeyCode() == base::VKEY_ESCAPE);
+  DCHECK(accelerator.GetKeyCode() == app::VKEY_ESCAPE);
   Close();
   return true;
 }
diff --git a/views/window/window_win.cc b/views/window/window_win.cc
index af03463..6aa5224 100644
--- a/views/window/window_win.cc
+++ b/views/window/window_win.cc
@@ -7,6 +7,7 @@
 #include <dwmapi.h>
 #include <shellapi.h>
 
+#include "app/keyboard_code_conversion_win.h"
 #include "app/theme_provider.h"
 #include "app/win_util.h"
 #include "base/i18n/rtl.h"
@@ -1120,7 +1121,7 @@ void WindowWin::OnSysCommand(UINT notification_code, CPoint click) {
   // Handle SC_KEYMENU, which means that the user has pressed the ALT
   // key and released it, so we should focus the menu bar.
   if ((notification_code & sc_mask) == SC_KEYMENU && click.x == 0) {
-    Accelerator accelerator(win_util::WinToKeyboardCode(VK_MENU),
+    Accelerator accelerator(app::KeyboardCodeForWindowsKeyCode(VK_MENU),
                             false, false, false);
     GetFocusManager()->ProcessAccelerator(accelerator);
     return;
diff --git a/webkit/support/DEPS b/webkit/support/DEPS
index e27e2eb..b42ea7d 100644
--- a/webkit/support/DEPS
+++ b/webkit/support/DEPS
@@ -1,3 +1,4 @@
 include_rules = [
+  "+app",
   "+media"
 ]
diff --git a/webkit/support/webkit_support.h b/webkit/support/webkit_support.h
index 6b82df8..1549ee0 100644
--- a/webkit/support/webkit_support.h
+++ b/webkit/support/webkit_support.h
@@ -7,8 +7,8 @@
 
 #include <string>
 
+#include "app/keyboard_codes.h"
 #include "base/basictypes.h"
-#include "base/keyboard_codes.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDevToolsAgentClient.h"
 
 class Task;
@@ -154,19 +154,19 @@ WebKit::WebURL GetDevToolsPathAsURL();
 
 // -------- Keyboard code
 enum {
-    VKEY_LEFT = base::VKEY_LEFT,
-    VKEY_RIGHT = base::VKEY_RIGHT,
-    VKEY_UP = base::VKEY_UP,
-    VKEY_DOWN = base::VKEY_DOWN,
-    VKEY_RETURN = base::VKEY_RETURN,
-    VKEY_INSERT = base::VKEY_INSERT,
-    VKEY_DELETE = base::VKEY_DELETE,
-    VKEY_PRIOR = base::VKEY_PRIOR,
-    VKEY_NEXT = base::VKEY_NEXT,
-    VKEY_HOME = base::VKEY_HOME,
-    VKEY_END = base::VKEY_END,
-    VKEY_SNAPSHOT = base::VKEY_SNAPSHOT,
-    VKEY_F1 = base::VKEY_F1,
+    VKEY_LEFT = app::VKEY_LEFT,
+    VKEY_RIGHT = app::VKEY_RIGHT,
+    VKEY_UP = app::VKEY_UP,
+    VKEY_DOWN = app::VKEY_DOWN,
+    VKEY_RETURN = app::VKEY_RETURN,
+    VKEY_INSERT = app::VKEY_INSERT,
+    VKEY_DELETE = app::VKEY_DELETE,
+    VKEY_PRIOR = app::VKEY_PRIOR,
+    VKEY_NEXT = app::VKEY_NEXT,
+    VKEY_HOME = app::VKEY_HOME,
+    VKEY_END = app::VKEY_END,
+    VKEY_SNAPSHOT = app::VKEY_SNAPSHOT,
+    VKEY_F1 = app::VKEY_F1,
 };
 
 }  // namespace webkit_support
diff --git a/webkit/tools/test_shell/event_sending_controller.cc b/webkit/tools/test_shell/event_sending_controller.cc
index 4b3c028..02d8078 100644
--- a/webkit/tools/test_shell/event_sending_controller.cc
+++ b/webkit/tools/test_shell/event_sending_controller.cc
@@ -19,10 +19,10 @@
 #include <queue>
 #include <vector>
 
+#include "app/keyboard_codes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
-#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ -215,16 +215,16 @@ bool GetEditCommand(const WebKeyboardEvent& event, std::string* name) {
     return false;
 
   switch (event.windowsKeyCode) {
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       *name = "MoveToBeginningOfLine";
       break;
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       *name = "MoveToEndOfLine";
       break;
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       *name = "MoveToBeginningOfDocument";
       break;
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       *name = "MoveToEndOfDocument";
       break;
     default:
@@ -555,29 +555,29 @@ void EventSendingController::keyDown(
     bool needs_shift_key_modifier = false;
     if (L"\n" == code_str) {
       generate_char = true;
-      text = code = base::VKEY_RETURN;
+      text = code = app::VKEY_RETURN;
     } else if (L"rightArrow" == code_str) {
-      code = base::VKEY_RIGHT;
+      code = app::VKEY_RIGHT;
     } else if (L"downArrow" == code_str) {
-      code = base::VKEY_DOWN;
+      code = app::VKEY_DOWN;
     } else if (L"leftArrow" == code_str) {
-      code = base::VKEY_LEFT;
+      code = app::VKEY_LEFT;
     } else if (L"upArrow" == code_str) {
-      code = base::VKEY_UP;
+      code = app::VKEY_UP;
     } else if (L"insert" == code_str) {
-      code = base::VKEY_INSERT;
+      code = app::VKEY_INSERT;
     } else if (L"delete" == code_str) {
-      code = base::VKEY_BACK;
+      code = app::VKEY_BACK;
     } else if (L"pageUp" == code_str) {
-      code = base::VKEY_PRIOR;
+      code = app::VKEY_PRIOR;
     } else if (L"pageDown" == code_str) {
-      code = base::VKEY_NEXT;
+      code = app::VKEY_NEXT;
     } else if (L"home" == code_str) {
-      code = base::VKEY_HOME;
+      code = app::VKEY_HOME;
     } else if (L"end" == code_str) {
-      code = base::VKEY_END;
+      code = app::VKEY_END;
     } else if (L"printScreen" == code_str) {
-      code = base::VKEY_SNAPSHOT;
+      code = app::VKEY_SNAPSHOT;
     } else {
       // Compare the input string with the function-key names defined by the
       // DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
@@ -587,7 +587,7 @@ void EventSendingController::keyDown(
         function_key_name += L"F";
         function_key_name += UTF8ToWide(base::IntToString(i));
         if (function_key_name == code_str) {
-          code = base::VKEY_F1 + (i - 1);
+          code = app::VKEY_F1 + (i - 1);
           break;
         }
       }
author	bryeung@chromium.org <bryeung@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2010-09-01 16:39:26 +0000
committer	bryeung@chromium.org <bryeung@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2010-09-01 16:39:26 +0000
commit	1eed61535cb6e15015edac43177ccdc25140855a (patch)
tree	843a3c3b42bfaadc54cd6c835e4c313965a0e177
parent	de6aadf4ddf69c76ddd60e03451fdbcb4061283f (diff)
download	chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.zip chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.tar.gz chromium_src-1eed61535cb6e15015edac43177ccdc25140855a.tar.bz2