Revert 58388 - Revert 58215 - Revert 58186 - Move the keyboard files from bas...

chrome/browser/automation/ui_controls_mac.mm

 // 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 "chrome/browser/automation/ui_controls.h"
 
 #import <Cocoa/Cocoa.h>
 #include <mach/mach_time.h>
 #include <vector>
 
-#include "app/keyboard_code_conversion_mac.h"
+#include "base/keyboard_code_conversion_mac.h"
 #include "base/message_loop.h"
 #include "chrome/browser/automation/ui_controls_internal.h"
 #include "chrome/browser/chrome_thread.h"
 
 // Implementation details: We use [NSApplication sendEvent:] instead
 // of [NSApplication postEvent:atStart:] so that the event gets sent
 // immediately.  This lets us run the post-event task right
 // immediately as well.  Unfortunately I cannot subclass NSEvent (it's
 // probably a class cluster) to allow other easy answers.  For
 // example, if I could subclass NSEvent, I could run the Task in it's
@@ skipping 47 matching lines @@
   return timeNano;
 }
 
 NSTimeInterval TimeIntervalSinceSystemStartup() {
   return UpTimeInNanoseconds() / 1000000000.0;
 }
 
 // Creates and returns an autoreleased key event.
 NSEvent* SynthesizeKeyEvent(NSWindow* window,
                             bool keyDown,
-                            app::KeyboardCode keycode,
+                            base::KeyboardCode keycode,
                             NSUInteger flags) {
   unichar character;
   unichar characterIgnoringModifiers;
-  int macKeycode = app::MacKeyCodeForWindowsKeyCode(
+  int macKeycode = base::MacKeyCodeForWindowsKeyCode(
       keycode, flags, &character, &characterIgnoringModifiers);
 
   if (macKeycode < 0)
     return nil;
 
   NSString* charactersIgnoringModifiers =
       [[[NSString alloc] initWithCharacters:&characterIgnoringModifiers
                                      length:1]
         autorelease];
   NSString* characters =
       [[[NSString alloc] initWithCharacters:&character length:1] autorelease];
 
   NSEventType type = (keyDown ? NSKeyDown : NSKeyUp);
 
   // Modifier keys generate NSFlagsChanged event rather than
   // NSKeyDown/NSKeyUp events.
-  if (keycode == app::VKEY_CONTROL || keycode == app::VKEY_SHIFT ||
-      keycode == app::VKEY_MENU || keycode == app::VKEY_COMMAND)
+  if (keycode == base::VKEY_CONTROL || keycode == base::VKEY_SHIFT ||
+      keycode == base::VKEY_MENU || keycode == base::VKEY_COMMAND)
     type = NSFlagsChanged;
 
   // For events other than mouse moved, [event locationInWindow] is
   // UNDEFINED if the event is not NSMouseMoved.  Thus, the (0,0)
   // location should be fine.
   NSEvent* event =
       [NSEvent keyEventWithType:type
                        location:NSMakePoint(0, 0)
                   modifierFlags:flags
                       timestamp:TimeIntervalSinceSystemStartup()
                    windowNumber:[window windowNumber]
                         context:nil
                      characters:characters
     charactersIgnoringModifiers:charactersIgnoringModifiers
                       isARepeat:NO
                         keyCode:(unsigned short)macKeycode];
 
   return event;
 }
 
 // Creates the proper sequence of autoreleased key events for a key down + up.
 void SynthesizeKeyEventsSequence(NSWindow* window,
-                                 app::KeyboardCode keycode,
+                                 base::KeyboardCode keycode,
                                  bool control,
                                  bool shift,
                                  bool alt,
                                  bool command,
                                  std::vector<NSEvent*>* events) {
   NSEvent* event = nil;
   NSUInteger flags = 0;
   if (control) {
     flags |= NSControlKeyMask;
-    event = SynthesizeKeyEvent(window, true, app::VKEY_CONTROL, flags);
+    event = SynthesizeKeyEvent(window, true, base::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (shift) {
     flags |= NSShiftKeyMask;
-    event = SynthesizeKeyEvent(window, true, app::VKEY_SHIFT, flags);
+    event = SynthesizeKeyEvent(window, true, base::VKEY_SHIFT, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (alt) {
     flags |= NSAlternateKeyMask;
-    event = SynthesizeKeyEvent(window, true, app::VKEY_MENU, flags);
+    event = SynthesizeKeyEvent(window, true, base::VKEY_MENU, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (command) {
     flags |= NSCommandKeyMask;
-    event = SynthesizeKeyEvent(window, true, app::VKEY_COMMAND, flags);
+    event = SynthesizeKeyEvent(window, true, base::VKEY_COMMAND, flags);
     DCHECK(event);
     events->push_back(event);
   }
 
   event = SynthesizeKeyEvent(window, true, keycode, flags);
   DCHECK(event);
   events->push_back(event);
   event = SynthesizeKeyEvent(window, false, keycode, flags);
   DCHECK(event);
   events->push_back(event);
 
   if (command) {
     flags &= ~NSCommandKeyMask;
-    event = SynthesizeKeyEvent(window, false, app::VKEY_COMMAND, flags);
+    event = SynthesizeKeyEvent(window, false, base::VKEY_COMMAND, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (alt) {
     flags &= ~NSAlternateKeyMask;
-    event = SynthesizeKeyEvent(window, false, app::VKEY_MENU, flags);
+    event = SynthesizeKeyEvent(window, false, base::VKEY_MENU, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (shift) {
     flags &= ~NSShiftKeyMask;
-    event = SynthesizeKeyEvent(window, false, app::VKEY_SHIFT, flags);
+    event = SynthesizeKeyEvent(window, false, base::VKEY_SHIFT, flags);
     DCHECK(event);
     events->push_back(event);
   }
   if (control) {
     flags &= ~NSControlKeyMask;
-    event = SynthesizeKeyEvent(window, false, app::VKEY_CONTROL, flags);
+    event = SynthesizeKeyEvent(window, false, base::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
 }
 
 // A task class to watch for the event queue. The specific task will be fired
 // when there is no more event in the queue.
 class EventQueueWatcher : public Task {
  public:
   EventQueueWatcher(Task* task) : task_(task) {}
@@ skipping 19 matching lines @@
 // Stores the current mouse location on the screen. So that we can use it
 // when firing keyboard and mouse click events.
 NSPoint g_mouse_location = { 0, 0 };
 
 }  // anonymous namespace
 
 
 namespace ui_controls {
 
 bool SendKeyPress(gfx::NativeWindow window,
-                  app::KeyboardCode key,
+                  base::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command) {
   return SendKeyPressNotifyWhenDone(window, key,
                                     control, shift, alt, command,
                                     NULL);
 }
 
 // Win and Linux implement a SendKeyPress() this as a
 // SendKeyPressAndRelease(), so we should as well (despite the name).
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
-                                app::KeyboardCode key,
+                                base::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
                                 bool command,
                                 Task* task) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   std::vector<NSEvent*> events;
   SynthesizeKeyEventsSequence(
       window, key, control, shift, alt, command, &events);
@@ skipping 125 matching lines @@
   NSPoint center = NSMakePoint(NSMidX(bounds), NSMidY(bounds));
   center = [view convertPoint:center toView:nil];
   center = [window convertBaseToScreen:center];
   center = NSMakePoint(center.x, [screen frame].size.height - center.y);
 
   SendMouseMoveNotifyWhenDone(center.x, center.y,
                               new ClickTask(button, state, task));
 }
 
 }  // ui_controls