Migrate Event API methods to Google Style.

Re-landing, moving the bits Mac uses to ui/base/events.h

BUG=72040
TEST=none
TBR=sky

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=74377



git-svn-id: svn://svn.chromium.org/chrome/trunk/src@74408 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 50 insertions, 50 deletions

diff --git a/chrome/browser/extensions/extension_input_api.cc b/chrome/browser/extensions/extension_input_api.cc
index bb91c00..b062fd4 100644
--- a/chrome/browser/extensions/extension_input_api.cc
+++ b/chrome/browser/extensions/extension_input_api.cc
@@ -39,13 +39,13 @@ const char kUnsupportedModifier[] = "Unsupported modifier.";
 const char kNoValidRecipientError[] = "No valid recipient for event.";
 const char kKeyEventUnprocessedError[] = "Event was not handled.";
 
-views::Event::EventType GetTypeFromString(const std::string& type) {
+ui::EventType GetTypeFromString(const std::string& type) {
   if (type == kKeyDown) {
-    return views::Event::ET_KEY_PRESSED;
+    return ui::ET_KEY_PRESSED;
   } else if (type == kKeyUp) {
-    return views::Event::ET_KEY_RELEASED;
+    return ui::ET_KEY_RELEASED;
   }
-  return views::Event::ET_UNKNOWN;
+  return ui::ET_UNKNOWN;
 }
 
 }  // namespace
@@ -77,8 +77,8 @@ bool SendKeyboardEventInputFunction::RunImpl() {
 
   std::string type_name;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(kType, &type_name));
-  views::Event::EventType type = GetTypeFromString(type_name);
-  if (type == views::Event::ET_UNKNOWN) {
+  ui::EventType type = GetTypeFromString(type_name);
+  if (type == ui::ET_UNKNOWN) {
     error_ = kUnknownEventTypeError;
     return false;
   }
@@ -89,21 +89,21 @@ bool SendKeyboardEventInputFunction::RunImpl() {
 
   const views::KeyEvent& prototype_event =
       KeyEventFromKeyIdentifier(identifier);
-  if (prototype_event.GetKeyCode() == ui::VKEY_UNKNOWN) {
+  if (prototype_event.key_code() == ui::VKEY_UNKNOWN) {
     error_ = kUnknownOrUnsupportedKeyIdentiferError;
     return false;
   }
 
-  int flags = prototype_event.GetFlags();
+  int flags = prototype_event.flags();
   bool alt = false;
   if (args->GetBoolean(kAlt, &alt))
-    flags |= alt ? views::Event::EF_ALT_DOWN : 0;
+    flags |= alt ? ui::EF_ALT_DOWN : 0;
   bool ctrl = false;
   if (args->GetBoolean(kCtrl, &ctrl))
-    flags |= ctrl ? views::Event::EF_CONTROL_DOWN : 0;
+    flags |= ctrl ? ui::EF_CONTROL_DOWN : 0;
   bool shift = false;
   if (args->GetBoolean(kShift, &shift))
-    flags |= shift ? views::Event::EF_SHIFT_DOWN : 0;
+    flags |= shift ? ui::EF_SHIFT_DOWN : 0;
   bool meta = false;
   if (args->GetBoolean(kMeta, &meta)) {
     // Views does not have a Meta event flag, so return an error for now.
@@ -119,7 +119,7 @@ bool SendKeyboardEventInputFunction::RunImpl() {
     return false;
   }
 
-  views::KeyEvent event(type, prototype_event.GetKeyCode(), flags, 0, 0);
+  views::KeyEvent event(type, prototype_event.key_code(), flags, 0, 0);
   if (!root_view->ProcessKeyEvent(event)) {
     error_ = kKeyEventUnprocessedError;
     return false;
diff --git a/chrome/browser/extensions/key_identifier_conversion_views.cc b/chrome/browser/extensions/key_identifier_conversion_views.cc
index 84dede3..de11ad7 100644
--- a/chrome/browser/extensions/key_identifier_conversion_views.cc
+++ b/chrome/browser/extensions/key_identifier_conversion_views.cc
@@ -159,18 +159,18 @@ static const KeyIdentifier kKeyIdentifiers[] = {
   { {"Cancel", "", "U+0018"}, ui::VKEY_UNKNOWN, 0 },
   { {"Esc", "", "U+001B"}, ui::VKEY_ESCAPE, 0 },
   { {"Spacebar", " ", "U+0020"}, ui::VKEY_SPACE, 0 },
-  { {"Exclamation", "!", "U+0021"}, ui::VKEY_1, views::Event::EF_SHIFT_DOWN },
+  { {"Exclamation", "!", "U+0021"}, ui::VKEY_1, ui::EF_SHIFT_DOWN },
   { {"DoubleQuote", "\"", "U+0022"},
-      ui::VKEY_OEM_7, views::Event::EF_SHIFT_DOWN },
-  { {"Hash", "#", "U+0023"}, ui::VKEY_3, views::Event::EF_SHIFT_DOWN },
-  { {"Dollar", "$", "U+0024"}, ui::VKEY_4, views::Event::EF_SHIFT_DOWN },
-  { {"Ampersand", "&", "U+0026"}, ui::VKEY_7, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_7, ui::EF_SHIFT_DOWN },
+  { {"Hash", "#", "U+0023"}, ui::VKEY_3, ui::EF_SHIFT_DOWN },
+  { {"Dollar", "$", "U+0024"}, ui::VKEY_4, ui::EF_SHIFT_DOWN },
+  { {"Ampersand", "&", "U+0026"}, ui::VKEY_7, ui::EF_SHIFT_DOWN },
   { {"Apostrophe", "\'", "U+0027"}, ui::VKEY_OEM_7, 0 },
-  { {"LeftParen", "(", "U+0028"}, ui::VKEY_9, views::Event::EF_SHIFT_DOWN },
-  { {"RightParen", ")", "U+0029"}, ui::VKEY_0, views::Event::EF_SHIFT_DOWN },
-  { {"Asterisk", "*", "U+002A"}, ui::VKEY_8, views::Event::EF_SHIFT_DOWN },
-  { {"Plus", "+", "U+002B"}, ui::VKEY_OEM_PLUS, views::Event::EF_SHIFT_DOWN },
-  { {"Percent", "%", "U+0025"}, ui::VKEY_5, views::Event::EF_SHIFT_DOWN },
+  { {"LeftParen", "(", "U+0028"}, ui::VKEY_9, ui::EF_SHIFT_DOWN },
+  { {"RightParen", ")", "U+0029"}, ui::VKEY_0, ui::EF_SHIFT_DOWN },
+  { {"Asterisk", "*", "U+002A"}, ui::VKEY_8, ui::EF_SHIFT_DOWN },
+  { {"Plus", "+", "U+002B"}, ui::VKEY_OEM_PLUS, ui::EF_SHIFT_DOWN },
+  { {"Percent", "%", "U+0025"}, ui::VKEY_5, ui::EF_SHIFT_DOWN },
   { {"Comma", ",", "U+002C"}, ui::VKEY_OEM_COMMA, 0 },
   { {"HyphenMinus", "-", "U+002D"}, ui::VKEY_OEM_MINUS, 0 },
   { {"Period", ".", "U+002E"}, ui::VKEY_OEM_PERIOD, 0 },
@@ -185,16 +185,16 @@ static const KeyIdentifier kKeyIdentifiers[] = {
   { {"", "7", "U+0037"}, ui::VKEY_7, 0 },
   { {"", "8", "U+0038"}, ui::VKEY_8, 0 },
   { {"", "9", "U+0039"}, ui::VKEY_9, 0 },
-  { {"Colon", ":", "U+003A"}, ui::VKEY_OEM_1, views::Event::EF_SHIFT_DOWN },
+  { {"Colon", ":", "U+003A"}, ui::VKEY_OEM_1, ui::EF_SHIFT_DOWN },
   { {"Semicolon", ";", "U+003B"}, ui::VKEY_OEM_1, 0 },
   { {"LessThan", "<", "U+003C"},
-      ui::VKEY_OEM_COMMA, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_COMMA, ui::EF_SHIFT_DOWN },
   { {"Equals", "=", "U+003D"}, ui::VKEY_OEM_PLUS, 0 },
   { {"GreaterThan", ">", "U+003E"},
-      ui::VKEY_OEM_PERIOD, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_PERIOD, ui::EF_SHIFT_DOWN },
   { {"QuestionMark", "?", "U+003F"},
-      ui::VKEY_OEM_2, views::Event::EF_SHIFT_DOWN },
-  { {"At", "@", "U+0040"}, ui::VKEY_2, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_2, ui::EF_SHIFT_DOWN },
+  { {"At", "@", "U+0040"}, ui::VKEY_2, ui::EF_SHIFT_DOWN },
   { {"", "A", "U+0041"}, ui::VKEY_A, 0 },
   { {"", "B", "U+0042"}, ui::VKEY_B, 0 },
   { {"", "C", "U+0043"}, ui::VKEY_C, 0 },
@@ -250,16 +250,16 @@ static const KeyIdentifier kKeyIdentifiers[] = {
   { {"LeftSquareBracket", "[", "U+005B"}, ui::VKEY_OEM_4, 0 },
   { {"Backslash", "\\", "U+005C"}, ui::VKEY_OEM_5, 0 },
   { {"RightSquareBracket", "]", "U+005D"}, ui::VKEY_OEM_6, 0 },
-  { {"Circumflex", "^", "U+005E"}, ui::VKEY_6, views::Event::EF_SHIFT_DOWN },
+  { {"Circumflex", "^", "U+005E"}, ui::VKEY_6, ui::EF_SHIFT_DOWN },
   { {"Underscore", "_", "U+005F"},
-      ui::VKEY_OEM_MINUS, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_MINUS, ui::EF_SHIFT_DOWN },
   { {"Grave", "`", "U+0060"}, ui::VKEY_OEM_3, 0 },
-  { {"Tilde", "~", "U+007E"}, ui::VKEY_OEM_3, views::Event::EF_SHIFT_DOWN },
+  { {"Tilde", "~", "U+007E"}, ui::VKEY_OEM_3, ui::EF_SHIFT_DOWN },
   { {"LeftCurlyBracket", "{", "U+007B"},
-      ui::VKEY_OEM_4, views::Event::EF_SHIFT_DOWN },
-  { {"Pipe", "|", "U+007C"}, ui::VKEY_OEM_5, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_4, ui::EF_SHIFT_DOWN },
+  { {"Pipe", "|", "U+007C"}, ui::VKEY_OEM_5, ui::EF_SHIFT_DOWN },
   { {"RightCurlyBracket", "}", "U+007D"},
-      ui::VKEY_OEM_6, views::Event::EF_SHIFT_DOWN },
+      ui::VKEY_OEM_6, ui::EF_SHIFT_DOWN },
   { {"Del", "", "U+007F"}, ui::VKEY_DELETE, 0 },
   { {"InvertedExclamation", "", "U+00A1"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadGrave", "", "U+0300"}, ui::VKEY_UNKNOWN, 0 },
@@ -294,7 +294,7 @@ static void InitializeMaps() {
     return;
 
   kUnknownKeyEvent = new views::KeyEvent(
-    views::Event::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, 0, 0);
+    ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, 0, 0);
 
   for (int i = 0; i < kNumIdentifierTypes; ++i)
     identifierMaps[i] = new IdentifierMap;
@@ -303,7 +303,7 @@ static void InitializeMaps() {
     const KeyIdentifier& key = kKeyIdentifiers[i];
 
     views::KeyEvent* event = new views::KeyEvent(
-        views::Event::ET_KEY_PRESSED, key.key_code, key.event_flags, 0, 0);
+        ui::ET_KEY_PRESSED, key.key_code, key.event_flags, 0, 0);
 
     for (int j = 0; j < kNumIdentifierTypes; ++j) {
       if (key.identifiers[j][0] != '\0') {
diff --git a/chrome/browser/extensions/key_identifier_conversion_views_unittest.cc b/chrome/browser/extensions/key_identifier_conversion_views_unittest.cc
index 79ce56e..43c7f76 100644
--- a/chrome/browser/extensions/key_identifier_conversion_views_unittest.cc
+++ b/chrome/browser/extensions/key_identifier_conversion_views_unittest.cc
@@ -23,40 +23,40 @@ class KeyEventFromKeyIdentifierTest : public testing::Test {
 };
 
 TEST_F(KeyEventFromKeyIdentifierTest, MatchOnIdentifier) {
-  EXPECT_EQ(ui::VKEY_APPS, KeyEventFromKeyIdentifier("Apps").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_APPS, KeyEventFromKeyIdentifier("Apps").key_code());
   EXPECT_EQ(ui::VKEY_UNKNOWN,
-      KeyEventFromKeyIdentifier("Nonsense").GetKeyCode());
+      KeyEventFromKeyIdentifier("Nonsense").key_code());
 }
 
 TEST_F(KeyEventFromKeyIdentifierTest, MatchOnCharacter) {
-  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("a").GetKeyCode());
-  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("A").GetKeyCode());
-  EXPECT_EQ(ui::VKEY_OEM_PERIOD, KeyEventFromKeyIdentifier(">").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("a").key_code());
+  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("A").key_code());
+  EXPECT_EQ(ui::VKEY_OEM_PERIOD, KeyEventFromKeyIdentifier(">").key_code());
 
   std::string non_printing_char(" ");
   non_printing_char[0] = static_cast<char>(1);
   EXPECT_EQ(ui::VKEY_UNKNOWN,
-      KeyEventFromKeyIdentifier(non_printing_char).GetKeyCode());
+      KeyEventFromKeyIdentifier(non_printing_char).key_code());
 }
 
 TEST_F(KeyEventFromKeyIdentifierTest, MatchOnUnicodeCodepoint) {
-  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("U+0041").GetKeyCode());
-  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("U+0061").GetKeyCode());
-  EXPECT_EQ(ui::VKEY_DELETE, KeyEventFromKeyIdentifier("U+007F").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("U+0041").key_code());
+  EXPECT_EQ(ui::VKEY_A, KeyEventFromKeyIdentifier("U+0061").key_code());
+  EXPECT_EQ(ui::VKEY_DELETE, KeyEventFromKeyIdentifier("U+007F").key_code());
 
   // this one exists in the map, but has no valid ui::VKEY
-  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("U+030A").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("U+030A").key_code());
 
   // this one is not in the map
-  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("U+0001").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("U+0001").key_code());
 }
 
 TEST_F(KeyEventFromKeyIdentifierTest, DoesNotMatchEmptyString) {
-  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("").GetKeyCode());
+  EXPECT_EQ(ui::VKEY_UNKNOWN, KeyEventFromKeyIdentifier("").key_code());
 }
 
 TEST_F(KeyEventFromKeyIdentifierTest, ShiftModifiersAreSet) {
-  EXPECT_EQ(0, KeyEventFromKeyIdentifier("1").GetFlags());
+  EXPECT_EQ(0, KeyEventFromKeyIdentifier("1").flags());
 
   const char* keys_with_shift[] = {
     "~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "_", "+",
@@ -65,8 +65,8 @@ TEST_F(KeyEventFromKeyIdentifierTest, ShiftModifiersAreSet) {
   int kNumKeysWithShift = arraysize(keys_with_shift);
 
   for (int i = 0; i < kNumKeysWithShift; ++i) {
-    EXPECT_EQ(views::Event::EF_SHIFT_DOWN,
-        KeyEventFromKeyIdentifier(keys_with_shift[i]).GetFlags());
+    EXPECT_EQ(ui::EF_SHIFT_DOWN,
+        KeyEventFromKeyIdentifier(keys_with_shift[i]).flags());
   }
 }