Move app/key* to ui/base/keycodes/*

webkit/tools/test_shell/event_sending_controller.cc

 // 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.
 
 // This file contains the definition for EventSendingController.
 //
 // Some notes about drag and drop handling:
 // Windows drag and drop goes through a system call to DoDragDrop.  At that
 // point, program control is given to Windows which then periodically makes
 // callbacks into the webview.  This won't work for layout tests, so instead,
 // we queue up all the mouse move and mouse up events.  When the test tries to
 // start a drag (by calling EvenSendingController::DoDragDrop), we take the
 // events in the queue and replay them.
 // The behavior of queuing events and replaying them can be disabled by a
 // layout test by setting eventSender.dragMode to false.
 
 #include "webkit/tools/test_shell/event_sending_controller.h"
 
 #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/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDragData.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDragOperation.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPoint.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebTouchPoint.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
+#include "ui/base/keycodes/keyboard_codes.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/test_shell.h"
 #include "webkit/tools/test_shell/test_webview_delegate.h"
 
 #if defined(OS_WIN)
 #include "third_party/WebKit/WebKit/chromium/public/win/WebInputEventFactory.h"
 using WebKit::WebInputEventFactory;
 #endif
 
 // TODO(mpcomplete): layout before each event?
@@ skipping 159 matching lines @@
   // modifiers. These key events correspond to some special movement and
   // selection editor commands, and was supposed to be handled in
   // third_party/WebKit/WebKit/chromium/src/EditorClientImpl.cpp. But these keys
   // will be marked as system key, which prevents them from being handled.
   // Thus they must be handled specially.
   if ((event.modifiers & ~WebKeyboardEvent::ShiftKey) !=
       WebKeyboardEvent::MetaKey)
     return false;
 
   switch (event.windowsKeyCode) {
-    case app::VKEY_LEFT:
+    case ui::VKEY_LEFT:
       *name = "MoveToBeginningOfLine";
       break;
-    case app::VKEY_RIGHT:
+    case ui::VKEY_RIGHT:
       *name = "MoveToEndOfLine";
       break;
-    case app::VKEY_UP:
+    case ui::VKEY_UP:
       *name = "MoveToBeginningOfDocument";
       break;
-    case app::VKEY_DOWN:
+    case ui::VKEY_DOWN:
       *name = "MoveToEndOfDocument";
       break;
     default:
       return false;
   }
 
   if (event.modifiers & WebKeyboardEvent::ShiftKey)
     name->append("AndModifySelection");
 
   return true;
@@ skipping 290 matching lines @@
     // TODO(mpcomplete): Should we also generate a KEY_UP?
     std::wstring code_str = UTF8ToWide(args[0].ToString());
 
     // Convert \n -> VK_RETURN.  Some layout tests use \n to mean "Enter", when
     // Windows uses \r for "Enter".
     int code = 0;
     int text = 0;
     bool needs_shift_key_modifier = false;
     if (L"\n" == code_str) {
       generate_char = true;
-      text = code = app::VKEY_RETURN;
+      text = code = ui::VKEY_RETURN;
     } else if (L"rightArrow" == code_str) {
-      code = app::VKEY_RIGHT;
+      code = ui::VKEY_RIGHT;
     } else if (L"downArrow" == code_str) {
-      code = app::VKEY_DOWN;
+      code = ui::VKEY_DOWN;
     } else if (L"leftArrow" == code_str) {
-      code = app::VKEY_LEFT;
+      code = ui::VKEY_LEFT;
     } else if (L"upArrow" == code_str) {
-      code = app::VKEY_UP;
+      code = ui::VKEY_UP;
     } else if (L"insert" == code_str) {
-      code = app::VKEY_INSERT;
+      code = ui::VKEY_INSERT;
     } else if (L"delete" == code_str) {
-      code = app::VKEY_DELETE;
+      code = ui::VKEY_DELETE;
     } else if (L"pageUp" == code_str) {
-      code = app::VKEY_PRIOR;
+      code = ui::VKEY_PRIOR;
     } else if (L"pageDown" == code_str) {
-      code = app::VKEY_NEXT;
+      code = ui::VKEY_NEXT;
     } else if (L"home" == code_str) {
-      code = app::VKEY_HOME;
+      code = ui::VKEY_HOME;
     } else if (L"end" == code_str) {
-      code = app::VKEY_END;
+      code = ui::VKEY_END;
     } else if (L"printScreen" == code_str) {
-      code = app::VKEY_SNAPSHOT;
+      code = ui::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
       // name, set its key code.
       for (int i = 1; i <= 24; ++i) {
         std::wstring function_key_name;
         function_key_name += L"F";
         function_key_name += UTF8ToWide(base::IntToString(i));
         if (function_key_name == code_str) {
-          code = app::VKEY_F1 + (i - 1);
+          code = ui::VKEY_F1 + (i - 1);
           break;
         }
       }
       if (!code) {
         DCHECK(code_str.length() == 1);
         text = code = code_str[0];
         needs_shift_key_modifier = NeedsShiftModifier(code);
         if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
           code -= 'a' - 'A';
         generate_char = true;
@@ skipping 195 matching lines @@
 //   changing the count based on flags also makes sense. This function
 //   is doing such for some flags.
 // - Some test even checks actual string content. So providing it
 //   would be also helpful.
 static std::vector<WebString>
 MakeMenuItemStringsFor(const WebKit::WebContextMenuData* context_menu,
                        MockSpellCheck* spellcheck) {
   // These constants are based on Safari's context menu because tests
   // are made for it.
   static const char* kNonEditableMenuStrings[] = {
-      "Back", "Reload Page", "Open in Dashbaord", "<separator>", 
-      "View Source", "Save Page As", "Print Page", "Inspect Element", 
+      "Back", "Reload Page", "Open in Dashbaord", "<separator>",
+      "View Source", "Save Page As", "Print Page", "Inspect Element",
       0 };
   static const char* kEditableMenuStrings[] = {
       "Cut", "Copy", "<separator>", "Paste", "Spelling and Grammar",
-      "Substitutions, Transformations", "Font", "Speech", 
+      "Substitutions, Transformations", "Font", "Speech",
       "Paragraph Direction", "<separator>", 0 };
 
   // This is possible because mouse events are cancelleable.
   if (!context_menu)
     return std::vector<WebString>();
 
   std::vector<WebString> strings;
 
   if (context_menu->isEditable) {
     for (const char** item = kEditableMenuStrings; *item; ++item)
@@ skipping 268 matching lines @@
 
 void EventSendingController::fireKeyboardEventsToElement(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }
 
 void EventSendingController::clearKillRing(
     const CppArgumentList& args, CppVariant* result) {
   result->SetNull();
 }