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
author: ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2011-02-10 04:56:36 +0000
committer: ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2011-02-10 04:56:36 +0000
commit: 8d577a70f6e6d2e47f0ac32f8606e489a7a77998 (patch)
tree: 48eae3f525e0323362db629efa2589e70a5a4e49
parent: 8fb0ecf45b286845fd2004a157a294d7e3ca7a39 (diff)
download: chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.zip
chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.tar.gz
chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.tar.bz2
103 files changed, 627 insertions, 636 deletions
diff --git a/app/app_base.gypi b/app/app_base.gypi
index 8c248d8..4faa4c5 100644
--- a/app/app_base.gypi
+++ b/app/app_base.gypi
@@ -131,6 +131,7 @@
         '../ui/base/dragdrop/os_exchange_data_provider_win.h',
         '../ui/base/dragdrop/os_exchange_data.cc',
         '../ui/base/dragdrop/os_exchange_data.h',
+        '../ui/base/events.h',
         '../ui/base/gtk/event_synthesis_gtk.cc',
         '../ui/base/gtk/event_synthesis_gtk.h',
         '../ui/base/gtk/gtk_signal.h',
diff --git a/chrome/browser/autocomplete/autocomplete_edit_view_views.cc b/chrome/browser/autocomplete/autocomplete_edit_view_views.cc
index c030c57..80baa0d 100644
--- a/chrome/browser/autocomplete/autocomplete_edit_view_views.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit_view_views.cc
@@ -165,21 +165,21 @@ bool AutocompleteEditViewViews::HandleAfterKeyEvent(
   if (content_maybe_changed_by_key_press_)
     OnAfterPossibleChange();
 
-  if (event.GetKeyCode() == ui::VKEY_RETURN) {
+  if (event.key_code() == ui::VKEY_RETURN) {
     bool alt_held = event.IsAltDown();
     model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     handled = true;
-  } else if (!handled && event.GetKeyCode() == ui::VKEY_ESCAPE) {
+  } else if (!handled && event.key_code() == ui::VKEY_ESCAPE) {
     // We can handle the Escape key if textfield did not handle it.
     // If it's not handled by us, then we need to propagate it up to the parent
     // widgets, so that Escape accelerator can still work.
     handled = model_->OnEscapeKeyPressed();
-  } else if (event.GetKeyCode() == ui::VKEY_CONTROL) {
+  } else if (event.key_code() == ui::VKEY_CONTROL) {
     // Omnibox2 can switch its contents while pressing a control key. To switch
     // the contents of omnibox2, we notify the AutocompleteEditModel class when
     // the control-key state is changed.
     model_->OnControlKeyChanged(true);
-  } else if (!text_changed_ && event.GetKeyCode() == ui::VKEY_DELETE &&
+  } else if (!text_changed_ && event.key_code() == ui::VKEY_DELETE &&
              event.IsShiftDown()) {
     // If shift+del didn't change the text, we let this delete an entry from
     // the popup.  We can't check to see if the IME handled it because even if
@@ -187,14 +187,14 @@ bool AutocompleteEditViewViews::HandleAfterKeyEvent(
     AutocompletePopupModel* popup_model = popup_view_->GetModel();
     if (popup_model->IsOpen())
       popup_model->TryDeletingCurrentItem();
-  } else if (!handled && event.GetKeyCode() == ui::VKEY_UP) {
+  } else if (!handled && event.key_code() == ui::VKEY_UP) {
     model_->OnUpOrDownKeyPressed(-1);
     handled = true;
-  } else if (!handled && event.GetKeyCode() == ui::VKEY_DOWN) {
+  } else if (!handled && event.key_code() == ui::VKEY_DOWN) {
     model_->OnUpOrDownKeyPressed(1);
     handled = true;
   } else if (!handled &&
-             event.GetKeyCode() == ui::VKEY_TAB &&
+             event.key_code() == ui::VKEY_TAB &&
              !event.IsShiftDown() &&
              !event.IsControlDown()) {
     if (model_->is_keyword_hint()) {
@@ -224,7 +224,7 @@ bool AutocompleteEditViewViews::HandleKeyReleaseEvent(
   // Omnibox2 can switch its contents while pressing a control key. To switch
   // the contents of omnibox2, we notify the AutocompleteEditModel class when
   // the control-key state is changed.
-  if (event.GetKeyCode() == ui::VKEY_CONTROL) {
+  if (event.key_code() == ui::VKEY_CONTROL) {
     // TODO(oshima): investigate if we need to support keyboard with two
     // controls. See autocomplete_edit_view_gtk.cc.
     model_->OnControlKeyChanged(false);
@@ -583,7 +583,7 @@ void AutocompleteEditViewViews::ContentsChanged(views::Textfield* sender,
 bool AutocompleteEditViewViews::HandleKeyEvent(
     views::Textfield* textfield,
     const views::KeyEvent& event) {
-  delete_was_pressed_ = event.GetKeyCode() == ui::VKEY_DELETE;
+  delete_was_pressed_ = event.key_code() == ui::VKEY_DELETE;
 
   // Reset |text_changed_| before passing the key event on to the text view.
   text_changed_ = false;
@@ -591,7 +591,7 @@ bool AutocompleteEditViewViews::HandleKeyEvent(
   handling_key_press_ = true;
   content_maybe_changed_by_key_press_ = false;
 
-  if (event.GetKeyCode() == ui::VKEY_BACK) {
+  if (event.key_code() == ui::VKEY_BACK) {
     // Checks if it's currently in keyword search mode.
     if (model_->is_keyword_hint() || model_->keyword().empty())
       return false;
diff --git a/chrome/browser/autocomplete/autocomplete_edit_view_win.cc b/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
index 6366873..889d682 100644
--- a/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
+++ b/chrome/browser/autocomplete/autocomplete_edit_view_win.cc
@@ -969,7 +969,7 @@ void AutocompleteEditViewWin::PasteAndGo(const string16& text) {
 
 bool AutocompleteEditViewWin::SkipDefaultKeyEventProcessing(
     const views::KeyEvent& e) {
-  ui::KeyboardCode key = e.GetKeyCode();
+  ui::KeyboardCode key = e.key_code();
   // 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 != ui::VKEY_HOME) &&
diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 9175049..255781ba 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -99,7 +99,6 @@
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "chrome/browser/automation/ui_controls.h"
-#include "views/events/event.h"
 #include "webkit/glue/password_form.h"
 
 #if defined(OS_WIN)
diff --git a/chrome/browser/automation/automation_provider_win.cc b/chrome/browser/automation/automation_provider_win.cc
index 5646c75..e0f76c9 100644
--- a/chrome/browser/automation/automation_provider_win.cc
+++ b/chrome/browser/automation/automation_provider_win.cc
@@ -79,7 +79,7 @@ BOOL CALLBACK EnumThreadWndProc(HWND hwnd, LPARAM l_param) {
 class MouseEventTask : public Task {
  public:
   MouseEventTask(views::View* view,
-                 views::Event::EventType type,
+                 ui::EventType type,
                  const gfx::Point& point,
                  int flags)
       : view_(view), type_(type), point_(point), flags_(flags) {}
@@ -97,15 +97,15 @@ class MouseEventTask : public Task {
     view_->ConvertPointToScreen(view_, &screen_location);
     MoveMouse(screen_location.ToPOINT());
     switch (type_) {
-      case views::Event::ET_MOUSE_PRESSED:
+      case ui::ET_MOUSE_PRESSED:
         view_->OnMousePressed(event);
         break;
 
-      case views::Event::ET_MOUSE_DRAGGED:
+      case ui::ET_MOUSE_DRAGGED:
         view_->OnMouseDragged(event);
         break;
 
-      case views::Event::ET_MOUSE_RELEASED:
+      case ui::ET_MOUSE_RELEASED:
         view_->OnMouseReleased(event, false);
         break;
 
@@ -116,7 +116,7 @@ class MouseEventTask : public Task {
 
  private:
   views::View* view_;
-  views::Event::EventType type_;
+  ui::EventType type_;
   gfx::Point point_;
   int flags_;
 
@@ -159,21 +159,21 @@ void AutomationProvider::WindowSimulateDrag(int handle,
     UINT down_message = 0;
     UINT up_message = 0;
     WPARAM wparam_flags = 0;
-    if (flags & views::Event::EF_SHIFT_DOWN)
+    if (flags & ui::EF_SHIFT_DOWN)
       wparam_flags |= MK_SHIFT;
-    if (flags & views::Event::EF_CONTROL_DOWN)
+    if (flags & ui::EF_CONTROL_DOWN)
       wparam_flags |= MK_CONTROL;
-    if (flags & views::Event::EF_LEFT_BUTTON_DOWN) {
+    if (flags & ui::EF_LEFT_BUTTON_DOWN) {
       wparam_flags |= MK_LBUTTON;
       down_message = WM_LBUTTONDOWN;
       up_message = WM_LBUTTONUP;
     }
-    if (flags & views::Event::EF_MIDDLE_BUTTON_DOWN) {
+    if (flags & ui::EF_MIDDLE_BUTTON_DOWN) {
       wparam_flags |= MK_MBUTTON;
       down_message = WM_MBUTTONDOWN;
       up_message = WM_MBUTTONUP;
     }
-    if (flags & views::Event::EF_RIGHT_BUTTON_DOWN) {
+    if (flags & ui::EF_RIGHT_BUTTON_DOWN) {
       wparam_flags |= MK_RBUTTON;
       down_message = WM_LBUTTONDOWN;
       up_message = WM_LBUTTONUP;
@@ -204,11 +204,11 @@ void AutomationProvider::WindowSimulateDrag(int handle,
       // TODO(phajdan.jr): make this use ui_test_utils::SendKeyPressSync.
       ui_controls::SendKeyPressNotifyWhenDone(
           window, ui::VKEY_ESCAPE,
-          ((flags & views::Event::EF_CONTROL_DOWN) ==
-           views::Event::EF_CONTROL_DOWN),
-          ((flags & views::Event::EF_SHIFT_DOWN) ==
-           views::Event::EF_SHIFT_DOWN),
-          ((flags & views::Event::EF_ALT_DOWN) == views::Event::EF_ALT_DOWN),
+          ((flags & ui::EF_CONTROL_DOWN) ==
+           ui::EF_CONTROL_DOWN),
+          ((flags & ui::EF_SHIFT_DOWN) ==
+           ui::EF_SHIFT_DOWN),
+          ((flags & ui::EF_ALT_DOWN) == ui::EF_ALT_DOWN),
           false,
           new MessageLoop::QuitTask());
       MessageLoopForUI* loop = MessageLoopForUI::current();
diff --git a/chrome/browser/automation/testing_automation_provider.cc b/chrome/browser/automation/testing_automation_provider.cc
index 529a052..6e718cb 100644
--- a/chrome/browser/automation/testing_automation_provider.cc
+++ b/chrome/browser/automation/testing_automation_provider.cc
@@ -79,8 +79,8 @@
 #include "net/base/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "ui/base/events.h"
 #include "ui/base/message_box_flags.h"
-#include "views/events/event.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 
 namespace {
@@ -115,14 +115,14 @@ void DeleteCookieOnIOThread(
 
 void SendMouseClick(int flags) {
   ui_controls::MouseButton button = ui_controls::LEFT;
-  if ((flags & views::Event::EF_LEFT_BUTTON_DOWN) ==
-      views::Event::EF_LEFT_BUTTON_DOWN) {
+  if ((flags & ui::EF_LEFT_BUTTON_DOWN) ==
+      ui::EF_LEFT_BUTTON_DOWN) {
     button = ui_controls::LEFT;
-  } else if ((flags & views::Event::EF_RIGHT_BUTTON_DOWN) ==
-             views::Event::EF_RIGHT_BUTTON_DOWN) {
+  } else if ((flags & ui::EF_RIGHT_BUTTON_DOWN) ==
+             ui::EF_RIGHT_BUTTON_DOWN) {
     button = ui_controls::RIGHT;
-  } else if ((flags & views::Event::EF_MIDDLE_BUTTON_DOWN) ==
-             views::Event::EF_MIDDLE_BUTTON_DOWN) {
+  } else if ((flags & ui::EF_MIDDLE_BUTTON_DOWN) ==
+             ui::EF_MIDDLE_BUTTON_DOWN) {
     button = ui_controls::MIDDLE;
   } else {
     NOTREACHED();
@@ -879,14 +879,14 @@ 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<ui::KeyboardCode>(key),
-                            ((flags & views::Event::EF_CONTROL_DOWN) ==
-                             views::Event::EF_CONTROL_DOWN),
-                            ((flags & views::Event::EF_SHIFT_DOWN) ==
-                             views::Event::EF_SHIFT_DOWN),
-                            ((flags & views::Event::EF_ALT_DOWN) ==
-                             views::Event::EF_ALT_DOWN),
-                            ((flags & views::Event::EF_COMMAND_DOWN) ==
-                             views::Event::EF_COMMAND_DOWN));
+                            ((flags & ui::EF_CONTROL_DOWN) ==
+                             ui::EF_CONTROL_DOWN),
+                            ((flags & ui::EF_SHIFT_DOWN) ==
+                             ui::EF_SHIFT_DOWN),
+                            ((flags & ui::EF_ALT_DOWN) ==
+                             ui::EF_ALT_DOWN),
+                            ((flags & ui::EF_COMMAND_DOWN) ==
+                             ui::EF_COMMAND_DOWN));
 }
 
 void TestingAutomationProvider::GetTabCount(int handle, int* tab_count) {
diff --git a/chrome/browser/bookmarks/bookmark_drop_info.cc b/chrome/browser/bookmarks/bookmark_drop_info.cc
index ba9d7a0..30d1f03 100644
--- a/chrome/browser/bookmarks/bookmark_drop_info.cc
+++ b/chrome/browser/bookmarks/bookmark_drop_info.cc
@@ -26,7 +26,7 @@ BookmarkDropInfo::~BookmarkDropInfo() {
 }
 
 void BookmarkDropInfo::Update(const views::DropTargetEvent& event) {
-  source_operations_ = event.GetSourceOperations();
+  source_operations_ = event.source_operations();
   is_control_down_ = event.IsControlDown();
   last_y_ = event.y();
 
diff --git a/chrome/browser/bookmarks/bookmark_utils.cc b/chrome/browser/bookmarks/bookmark_utils.cc
index 6e26e9b..898e5a9 100644
--- a/chrome/browser/bookmarks/bookmark_utils.cc
+++ b/chrome/browser/bookmarks/bookmark_utils.cc
@@ -35,11 +35,11 @@
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/tree_node_iterator.h"
-#include "views/events/event.h"
 
 #if defined(TOOLKIT_VIEWS)
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "views/drag_utils.h"
+#include "views/events/event.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 #elif defined(TOOLKIT_GTK)
@@ -227,6 +227,7 @@ int BookmarkDragOperation(const BookmarkNode* node) {
   return ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE;
 }
 
+#if defined(TOOLKIT_VIEWS)
 int BookmarkDropOperation(Profile* profile,
                           const views::DropTargetEvent& event,
                           const BookmarkNodeData& data,
@@ -244,9 +245,10 @@ int BookmarkDropOperation(Profile* profile,
     return ui::DragDropTypes::DRAG_MOVE;
   }
   // User is dragging from another app, copy.
-  return PreferredDropOperation(event.GetSourceOperations(),
+  return PreferredDropOperation(event.source_operations(),
       ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK);
 }
+#endif  // defined(TOOLKIT_VIEWS)
 
 int PerformBookmarkDrop(Profile* profile,
                         const BookmarkNodeData& data,
diff --git a/chrome/browser/chromeos/login/background_view.cc b/chrome/browser/chromeos/login/background_view.cc
index 3490e9b..dae33363 100644
--- a/chrome/browser/chromeos/login/background_view.cc
+++ b/chrome/browser/chromeos/login/background_view.cc
@@ -83,7 +83,7 @@ class TextButtonWithHandCursorOver : public views::TextButton {
   virtual ~TextButtonWithHandCursorOver() {}
 
   virtual gfx::NativeCursor GetCursorForPoint(
-      views::Event::EventType event_type,
+      ui::EventType event_type,
       const gfx::Point& p) {
     if (!IsEnabled()) {
       return NULL;
diff --git a/chrome/browser/chromeos/login/captcha_view.cc b/chrome/browser/chromeos/login/captcha_view.cc
index 4126832..c4c295b 100644
--- a/chrome/browser/chromeos/login/captcha_view.cc
+++ b/chrome/browser/chromeos/login/captcha_view.cc
@@ -123,7 +123,7 @@ void CaptchaView::ViewHierarchyChanged(bool is_add,
 bool CaptchaView::HandleKeyEvent(views::Textfield* sender,
                                  const views::KeyEvent& key_event) {
   if (sender == captcha_textfield_ &&
-      key_event.GetKeyCode() == ui::VKEY_RETURN) {
+      key_event.key_code() == ui::VKEY_RETURN) {
     if (is_standalone_) {
       Accept();
     } else {
diff --git a/chrome/browser/chromeos/login/existing_user_view.cc b/chrome/browser/chromeos/login/existing_user_view.cc
index dcf100f..8655351 100644
--- a/chrome/browser/chromeos/login/existing_user_view.cc
+++ b/chrome/browser/chromeos/login/existing_user_view.cc
@@ -33,13 +33,13 @@ class UserEntryTextfield : public TextfieldWithMargin {
 
   // Overridden from views::View:
   virtual bool OnKeyPressed(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == ui::VKEY_TAB) {
+    if (e.key_code() == ui::VKEY_TAB) {
       controller_->SelectUserRelative(e.IsShiftDown() ? -1 : 1);
       return true;
-    } else if (e.GetKeyCode() == ui::VKEY_LEFT) {
+    } else if (e.key_code() == ui::VKEY_LEFT) {
       controller_->SelectUserRelative(-1);
       return true;
-    } else if (e.GetKeyCode() == ui::VKEY_RIGHT) {
+    } else if (e.key_code() == ui::VKEY_RIGHT) {
       controller_->SelectUserRelative(1);
       return true;
     } else {
@@ -48,7 +48,7 @@ class UserEntryTextfield : public TextfieldWithMargin {
   }
 
   virtual bool SkipDefaultKeyEventProcessing(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == ui::VKEY_TAB)
+    if (e.key_code() == ui::VKEY_TAB)
       return true;
     else
       return views::Textfield::SkipDefaultKeyEventProcessing(e);
@@ -104,7 +104,7 @@ bool ExistingUserView::AcceleratorPressed(
 
 bool ExistingUserView::HandleKeyEvent(views::Textfield* sender,
                                       const views::KeyEvent& key_event) {
-  if (key_event.GetKeyCode() == ui::VKEY_RETURN) {
+  if (key_event.key_code() == ui::VKEY_RETURN) {
     if (!password_field_->text().empty())
       user_controller_->OnLogin("", UTF16ToUTF8(password_field_->text()));
   } else {
diff --git a/chrome/browser/chromeos/login/guest_user_view.cc b/chrome/browser/chromeos/login/guest_user_view.cc
index 5f9b9b5..02978e2 100644
--- a/chrome/browser/chromeos/login/guest_user_view.cc
+++ b/chrome/browser/chromeos/login/guest_user_view.cc
@@ -23,7 +23,7 @@ class UserEntryButton : public login::WideButton {
 
   // Overridden from views::View:
   virtual bool OnKeyPressed(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == ui::VKEY_TAB) {
+    if (e.key_code() == ui::VKEY_TAB) {
       user_controller_->SelectUserRelative(e.IsShiftDown() ? -1 : 1);
       return true;
     }
@@ -31,7 +31,7 @@ class UserEntryButton : public login::WideButton {
   }
 
   virtual bool SkipDefaultKeyEventProcessing(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == ui::VKEY_TAB)
+    if (e.key_code() == ui::VKEY_TAB)
       return true;
     return WideButton::SkipDefaultKeyEventProcessing(e);
   }
diff --git a/chrome/browser/chromeos/login/network_screen_browsertest.cc b/chrome/browser/chromeos/login/network_screen_browsertest.cc
index 2a2dee5..3bca37d 100644
--- a/chrome/browser/chromeos/login/network_screen_browsertest.cc
+++ b/chrome/browser/chromeos/login/network_screen_browsertest.cc
@@ -118,9 +118,9 @@ class NetworkScreenTest : public WizardInProcessBrowserTest {
     controller()->set_observer(mock_screen_observer.get());
     DummyButtonListener button_listener;
     views::TextButton button(&button_listener, L"Button");
-    views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
+    views::MouseEvent event(ui::ET_MOUSE_RELEASED,
                             0, 0,
-                            views::Event::EF_LEFT_BUTTON_DOWN);
+                            ui::EF_LEFT_BUTTON_DOWN);
     network_screen->ButtonPressed(&button, event);
     ui_test_utils::RunAllPendingInMessageLoop();
     controller()->set_observer(NULL);
diff --git a/chrome/browser/chromeos/login/new_user_view.cc b/chrome/browser/chromeos/login/new_user_view.cc
index 121cf9f..ab17d64 100644
--- a/chrome/browser/chromeos/login/new_user_view.cc
+++ b/chrome/browser/chromeos/login/new_user_view.cc
@@ -85,7 +85,7 @@ class UsernameField : public chromeos::TextfieldWithMargin {
 
   // Overridden from views::View:
   virtual bool OnKeyPressed(const views::KeyEvent& e) {
-    if (e.GetKeyCode() == ui::VKEY_LEFT) {
+    if (e.key_code() == ui::VKEY_LEFT) {
       return controller_->NavigateAway();
     }
     return false;
@@ -512,7 +512,7 @@ bool NewUserView::HandleKeyEvent(views::Textfield* sender,
   if (!CrosLibrary::Get()->EnsureLoaded() || login_in_process_)
     return false;
 
-  if (key_event.GetKeyCode() == ui::VKEY_RETURN) {
+  if (key_event.key_code() == ui::VKEY_RETURN) {
     if (!username_field_->text().empty() && !password_field_->text().empty())
       Login();
     // Return true so that processing ends
diff --git a/chrome/browser/chromeos/login/screen_lock_view.cc b/chrome/browser/chromeos/login/screen_lock_view.cc
index e74710a..0ebcd09 100644
--- a/chrome/browser/chromeos/login/screen_lock_view.cc
+++ b/chrome/browser/chromeos/login/screen_lock_view.cc
@@ -198,7 +198,7 @@ bool ScreenLockView::HandleKeyEvent(
     views::Textfield* sender,
     const views::KeyEvent& key_event) {
   screen_locker_->ClearErrors();
-  if (key_event.GetKeyCode() == ui::VKEY_RETURN) {
+  if (key_event.key_code() == ui::VKEY_RETURN) {
     screen_locker_->Authenticate(password_field_->text());
     return true;
   }
diff --git a/chrome/browser/chromeos/login/shutdown_button.cc b/chrome/browser/chromeos/login/shutdown_button.cc
index 138467c..d66b879 100644
--- a/chrome/browser/chromeos/login/shutdown_button.cc
+++ b/chrome/browser/chromeos/login/shutdown_button.cc
@@ -116,7 +116,7 @@ void ShutdownButton::OnLocaleChanged() {
 }
 
 gfx::NativeCursor ShutdownButton::GetCursorForPoint(
-    views::Event::EventType event_type,
+    ui::EventType event_type,
     const gfx::Point& p) {
   if (!IsEnabled()) {
     return NULL;
diff --git a/chrome/browser/chromeos/login/shutdown_button.h b/chrome/browser/chromeos/login/shutdown_button.h
index dd0a65a..15cb2ad 100644
--- a/chrome/browser/chromeos/login/shutdown_button.h
+++ b/chrome/browser/chromeos/login/shutdown_button.h
@@ -26,7 +26,7 @@ class ShutdownButton : public views::TextButton,
   // views::View overrides.
   virtual void OnLocaleChanged();
   virtual gfx::NativeCursor GetCursorForPoint(
-      views::Event::EventType event_type,
+      ui::EventType event_type,
       const gfx::Point& p);
 
   // views::ButtonListener implementation.
diff --git a/chrome/browser/chromeos/login/textfield_with_margin.cc b/chrome/browser/chromeos/login/textfield_with_margin.cc
index 38cadb7..eb75416 100644
--- a/chrome/browser/chromeos/login/textfield_with_margin.cc
+++ b/chrome/browser/chromeos/login/textfield_with_margin.cc
@@ -36,7 +36,7 @@ void TextfieldWithMargin::Layout() {
 }
 
 bool TextfieldWithMargin::OnKeyPressed(const views::KeyEvent& e) {
-  if (e.GetKeyCode() == ui::VKEY_ESCAPE && !text().empty()) {
+  if (e.key_code() == ui::VKEY_ESCAPE && !text().empty()) {
     SetText(string16());
     return true;
   }
diff --git a/chrome/browser/chromeos/login/user_view.cc b/chrome/browser/chromeos/login/user_view.cc
index 3b07efd..85ef9df 100644
--- a/chrome/browser/chromeos/login/user_view.cc
+++ b/chrome/browser/chromeos/login/user_view.cc
@@ -235,7 +235,7 @@ class PodImageView : public views::ImageView {
   }
 
   gfx::NativeCursor GetCursorForPoint(
-      views::Event::EventType event_type,
+      ui::EventType event_type,
       const gfx::Point& p) {
     return (delegate_->IsUserSelected()) ? NULL : gfx::GetCursor(GDK_HAND2);
   }
diff --git a/chrome/browser/chromeos/login/username_view.cc b/chrome/browser/chromeos/login/username_view.cc
index fedf340..db22e2b 100644
--- a/chrome/browser/chromeos/login/username_view.cc
+++ b/chrome/browser/chromeos/login/username_view.cc
@@ -97,7 +97,7 @@ UsernameView* UsernameView::CreateShapedUsernameView(
 }
 
 gfx::NativeCursor UsernameView::GetCursorForPoint(
-    views::Event::EventType event_type,
+    ui::EventType event_type,
     const gfx::Point& p) {
   return use_small_shape_ ? gfx::GetCursor(GDK_HAND2) : NULL;
 }
diff --git a/chrome/browser/chromeos/login/username_view.h b/chrome/browser/chromeos/login/username_view.h
index 3a6245a..12ec105 100644
--- a/chrome/browser/chromeos/login/username_view.h
+++ b/chrome/browser/chromeos/login/username_view.h
@@ -46,7 +46,7 @@ class UsernameView : public views::Label {
  private:
   // Overriden from View.
   virtual gfx::NativeCursor GetCursorForPoint(
-      views::Event::EventType event_type,
+      ui::EventType event_type,
       const gfx::Point& p);
   virtual void OnLocaleChanged();
 
diff --git a/chrome/browser/chromeos/options/wifi_config_view.cc b/chrome/browser/chromeos/options/wifi_config_view.cc
index f55c1b5..e419994 100644
--- a/chrome/browser/chromeos/options/wifi_config_view.cc
+++ b/chrome/browser/chromeos/options/wifi_config_view.cc
@@ -152,7 +152,7 @@ void WifiConfigView::ContentsChanged(views::Textfield* sender,
 bool WifiConfigView::HandleKeyEvent(views::Textfield* sender,
                                     const views::KeyEvent& key_event) {
   if (sender == passphrase_textfield_ &&
-      key_event.GetKeyCode() == ui::VKEY_RETURN) {
+      key_event.key_code() == ui::VKEY_RETURN) {
     parent_->GetDialogClientView()->AcceptWindow();
   }
   return false;
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());
   }
 }
 
diff --git a/chrome/browser/history/redirect_uitest.cc b/chrome/browser/history/redirect_uitest.cc
index 55d33bb..904ba86 100644
--- a/chrome/browser/history/redirect_uitest.cc
+++ b/chrome/browser/history/redirect_uitest.cc
@@ -22,7 +22,7 @@
 #include "chrome/test/ui/ui_test.h"
 #include "net/base/net_util.h"
 #include "net/test/test_server.h"
-#include "views/events/event.h"
+#include "ui/base/events.h"
 
 namespace {
 
@@ -165,9 +165,8 @@ TEST_F(RedirectTest, MAYBE_ClientCancelled) {
   ASSERT_TRUE(browser->BringToFront());
   ASSERT_TRUE(window->GetViewBounds(VIEW_ID_TAB_CONTAINER, &tab_view_bounds,
                                     true));
-  ASSERT_TRUE(
-      window->SimulateOSClick(tab_view_bounds.CenterPoint(),
-                              views::Event::EF_LEFT_BUTTON_DOWN));
+  ASSERT_TRUE(window->SimulateOSClick(tab_view_bounds.CenterPoint(),
+                                      ui::EF_LEFT_BUTTON_DOWN));
   EXPECT_TRUE(tab_proxy->WaitForNavigation(last_nav_time));
 
   std::vector<GURL> redirects;
diff --git a/chrome/browser/renderer_host/render_widget_host_view_views.cc b/chrome/browser/renderer_host/render_widget_host_view_views.cc
index 0e1df3d..77955d0 100644
--- a/chrome/browser/renderer_host/render_widget_host_view_views.cc
+++ b/chrome/browser/renderer_host/render_widget_host_view_views.cc
@@ -60,13 +60,13 @@ int WebInputEventFlagsFromViewsEvent(const views::Event& event) {
 WebKit::WebTouchPoint::State TouchPointStateFromEvent(
     const views::TouchEvent* event) {
   switch (event->GetType()) {
-    case views::Event::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_PRESSED:
       return WebKit::WebTouchPoint::StatePressed;
-    case views::Event::ET_TOUCH_RELEASED:
+    case ui::ET_TOUCH_RELEASED:
       return WebKit::WebTouchPoint::StateReleased;
-    case views::Event::ET_TOUCH_MOVED:
+    case ui::ET_TOUCH_MOVED:
       return WebKit::WebTouchPoint::StateMoved;
-    case views::Event::ET_TOUCH_CANCELLED:
+    case ui::ET_TOUCH_CANCELLED:
       return WebKit::WebTouchPoint::StateCancelled;
     default:
       return WebKit::WebTouchPoint::StateUndefined;
@@ -76,13 +76,13 @@ WebKit::WebTouchPoint::State TouchPointStateFromEvent(
 WebKit::WebInputEvent::Type TouchEventTypeFromEvent(
     const views::TouchEvent* event) {
   switch (event->GetType()) {
-    case views::Event::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_PRESSED:
       return WebKit::WebInputEvent::TouchStart;
-    case views::Event::ET_TOUCH_RELEASED:
+    case ui::ET_TOUCH_RELEASED:
       return WebKit::WebInputEvent::TouchEnd;
-    case views::Event::ET_TOUCH_MOVED:
+    case ui::ET_TOUCH_MOVED:
       return WebKit::WebInputEvent::TouchMove;
-    case views::Event::ET_TOUCH_CANCELLED:
+    case ui::ET_TOUCH_CANCELLED:
       return WebKit::WebInputEvent::TouchCancel;
     default:
       return WebKit::WebInputEvent::Undefined;
@@ -446,7 +446,7 @@ void RenderWidgetHostViewViews::Paint(gfx::Canvas* canvas) {
 }
 
 gfx::NativeCursor RenderWidgetHostViewViews::GetCursorForPoint(
-    views::Event::EventType type, const gfx::Point& point) {
+    ui::EventType type, const gfx::Point& point) {
   return native_cursor_;
 }
 
@@ -684,7 +684,7 @@ views::View::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
   TouchStatus status = TOUCH_STATUS_UNKNOWN;
 
   switch (e.GetType()) {
-    case views::Event::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_PRESSED:
       // Add a new touch point.
       if (touch_event_.touchPointsLength <
           WebTouchEvent::touchPointsLengthCap) {
@@ -700,9 +700,9 @@ views::View::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
         }
       }
       break;
-    case views::Event::ET_TOUCH_RELEASED:
-    case views::Event::ET_TOUCH_CANCELLED:
-    case views::Event::ET_TOUCH_MOVED: {
+    case ui::ET_TOUCH_RELEASED:
+    case ui::ET_TOUCH_CANCELLED:
+    case ui::ET_TOUCH_MOVED: {
       // The touch point should have been added to the event from an earlier
       // _PRESSED event. So find that.
       // At the moment, only a maximum of 4 touch-points are allowed. So a
@@ -755,7 +755,7 @@ views::View::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
   host_->ForwardTouchEvent(touch_event_);
 
   // If the touch was released, then remove it from the list of touch points.
-  if (e.GetType() == views::Event::ET_TOUCH_RELEASED) {
+  if (e.GetType() == ui::ET_TOUCH_RELEASED) {
     --touch_event_.touchPointsLength;
     for (int i = point - touch_event_.touchPoints;
          i < touch_event_.touchPointsLength;
@@ -764,7 +764,7 @@ views::View::TouchStatus RenderWidgetHostViewViews::OnTouchEvent(
     }
     if (touch_event_.touchPointsLength == 0)
       status = TOUCH_STATUS_END;
-  } else if (e.GetType() == views::Event::ET_TOUCH_CANCELLED) {
+  } else if (e.GetType() == ui::ET_TOUCH_CANCELLED) {
     status = TOUCH_STATUS_CANCEL;
   }
 
diff --git a/chrome/browser/renderer_host/render_widget_host_view_views.h b/chrome/browser/renderer_host/render_widget_host_view_views.h
index 064a21e..4451196 100644
--- a/chrome/browser/renderer_host/render_widget_host_view_views.h
+++ b/chrome/browser/renderer_host/render_widget_host_view_views.h
@@ -88,7 +88,7 @@ class RenderWidgetHostViewViews : public RenderWidgetHostView,
 
   // Overridden from views::View.
   virtual std::string GetClassName() const;
-  gfx::NativeCursor GetCursorForPoint(views::Event::EventType type,
+  gfx::NativeCursor GetCursorForPoint(ui::EventType type,
                                       const gfx::Point& point);
 
   // Views mouse events, overridden from views::View.
diff --git a/chrome/browser/ui/views/bookmark_bar_view.cc b/chrome/browser/ui/views/bookmark_bar_view.cc
index d0d9510..af27fec 100644
--- a/chrome/browser/ui/views/bookmark_bar_view.cc
+++ b/chrome/browser/ui/views/bookmark_bar_view.cc
@@ -193,12 +193,12 @@ class BookmarkFolderButton : public views::MenuButton {
   virtual bool IsTriggerableEvent(const views::MouseEvent& e) {
     // Left clicks should show the menu contents and right clicks should show
     // the context menu. They should not trigger the opening of underlying urls.
-    if (e.GetFlags() == views::MouseEvent::EF_LEFT_BUTTON_DOWN ||
-        e.GetFlags() == views::MouseEvent::EF_RIGHT_BUTTON_DOWN)
+    if (e.flags() == ui::EF_LEFT_BUTTON_DOWN ||
+        e.flags() == ui::EF_RIGHT_BUTTON_DOWN)
       return false;
 
     WindowOpenDisposition disposition(
-        event_utils::DispositionFromEventFlags(e.GetFlags()));
+        event_utils::DispositionFromEventFlags(e.flags()));
     return disposition != CURRENT_TAB;
   }
 
@@ -1402,9 +1402,8 @@ int BookmarkBarView::CalculateDropOperation(const DropTargetEvent& event,
     int ops = data.GetFirstNode(profile_)
         ? ui::DragDropTypes::DRAG_MOVE
         : ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
-    return
-        bookmark_utils::PreferredDropOperation(event.GetSourceOperations(),
-                                               ops);
+    return bookmark_utils::PreferredDropOperation(event.source_operations(),
+                                                  ops);
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
diff --git a/chrome/browser/ui/views/browser_actions_container.cc b/chrome/browser/ui/views/browser_actions_container.cc
index 8a2b9a1..77ecd07 100644
--- a/chrome/browser/ui/views/browser_actions_container.cc
+++ b/chrome/browser/ui/views/browser_actions_container.cc
@@ -699,7 +699,7 @@ void BrowserActionsContainer::OnDragExited() {
 int BrowserActionsContainer::OnPerformDrop(
     const views::DropTargetEvent& event) {
   BrowserActionDragData data;
-  if (!data.Read(event.GetData()))
+  if (!data.Read(event.data()))
     return ui::DragDropTypes::DRAG_NONE;
 
   // Make sure we have the same view as we started with.
diff --git a/chrome/browser/ui/views/content_setting_bubble_contents.cc b/chrome/browser/ui/views/content_setting_bubble_contents.cc
index c2b93d7..1fa8a2f 100644
--- a/chrome/browser/ui/views/content_setting_bubble_contents.cc
+++ b/chrome/browser/ui/views/content_setting_bubble_contents.cc
@@ -57,9 +57,8 @@ class ContentSettingBubbleContents::Favicon : public views::ImageView {
   // views::View overrides:
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual void OnMouseReleased(const views::MouseEvent& event, bool canceled);
-  virtual gfx::NativeCursor GetCursorForPoint(
-      views::Event::EventType event_type,
-      const gfx::Point& p);
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
+                                              const gfx::Point& p);
 
   ContentSettingBubbleContents* parent_;
   views::Link* link_;
@@ -92,11 +91,11 @@ void ContentSettingBubbleContents::Favicon::OnMouseReleased(
   if (!canceled &&
       (event.IsLeftMouseButton() || event.IsMiddleMouseButton()) &&
       HitTest(event.location()))
-    parent_->LinkActivated(link_, event.GetFlags());
+    parent_->LinkActivated(link_, event.flags());
 }
 
 gfx::NativeCursor ContentSettingBubbleContents::Favicon::GetCursorForPoint(
-    views::Event::EventType event_type,
+    ui::EventType event_type,
     const gfx::Point& p) {
 #if defined(OS_WIN)
   if (!g_hand_cursor)
diff --git a/chrome/browser/ui/views/download_item_view.cc b/chrome/browser/ui/views/download_item_view.cc
index ff2d44f..92f5c341 100644
--- a/chrome/browser/ui/views/download_item_view.cc
+++ b/chrome/browser/ui/views/download_item_view.cc
@@ -876,8 +876,7 @@ bool DownloadItemView::OnKeyPressed(const views::KeyEvent& e) {
   if (IsDangerousMode())
     return true;
 
-  if (e.GetKeyCode() == ui::VKEY_SPACE ||
-      e.GetKeyCode() == ui::VKEY_RETURN) {
+  if (e.key_code() == ui::VKEY_SPACE || e.key_code() == ui::VKEY_RETURN) {
     OpenDownload();
     return true;
   }
diff --git a/chrome/browser/ui/views/dropdown_bar_host_win.cc b/chrome/browser/ui/views/dropdown_bar_host_win.cc
index f08db1d..0f0ce6a 100644
--- a/chrome/browser/ui/views/dropdown_bar_host_win.cc
+++ b/chrome/browser/ui/views/dropdown_bar_host_win.cc
@@ -17,7 +17,7 @@ NativeWebKeyboardEvent DropdownBarHost::GetKeyboardEvent(
      const TabContents* contents,
      const views::KeyEvent& key_event) {
   HWND hwnd = contents->GetContentNativeView();
-  WORD key = WindowsKeyCodeForKeyboardCode(key_event.GetKeyCode());
+  WORD key = WindowsKeyCodeForKeyboardCode(key_event.key_code());
 
   return NativeWebKeyboardEvent(hwnd, key_event.message(), key, 0);
 }
diff --git a/chrome/browser/ui/views/event_utils.cc b/chrome/browser/ui/views/event_utils.cc
index 2677f19..8c59c51 100644
--- a/chrome/browser/ui/views/event_utils.cc
+++ b/chrome/browser/ui/views/event_utils.cc
@@ -11,15 +11,15 @@ using views::Event;
 namespace event_utils {
 
 WindowOpenDisposition DispositionFromEventFlags(int event_flags) {
-  if (((event_flags & Event::EF_MIDDLE_BUTTON_DOWN) ==
-          Event::EF_MIDDLE_BUTTON_DOWN) ||
-      ((event_flags & Event::EF_CONTROL_DOWN) ==
-          Event::EF_CONTROL_DOWN)) {
-    return ((event_flags & Event::EF_SHIFT_DOWN) ==  Event::EF_SHIFT_DOWN) ?
+  if (((event_flags & ui::EF_MIDDLE_BUTTON_DOWN) ==
+          ui::EF_MIDDLE_BUTTON_DOWN) ||
+      ((event_flags & ui::EF_CONTROL_DOWN) ==
+          ui::EF_CONTROL_DOWN)) {
+    return ((event_flags & ui::EF_SHIFT_DOWN) ==  ui::EF_SHIFT_DOWN) ?
         NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   }
 
-  if ((event_flags & Event::EF_SHIFT_DOWN) == Event::EF_SHIFT_DOWN)
+  if ((event_flags & ui::EF_SHIFT_DOWN) == ui::EF_SHIFT_DOWN)
     return NEW_WINDOW;
   return false /*event.IsAltDown()*/ ? SAVE_TO_DISK : CURRENT_TAB;
 }
diff --git a/chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.cc b/chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.cc
index 3c6260d..549017d 100644
--- a/chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.cc
+++ b/chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.cc
@@ -148,7 +148,7 @@ int BrowserActionOverflowMenuController::GetDropOperation(
   // (because we don't shrink the BrowserActionContainer when you do this).
   if ((item->GetCommand() == 0) && (*position == DROP_BEFORE)) {
     BrowserActionDragData drop_data;
-    if (!drop_data.Read(event.GetData()))
+    if (!drop_data.Read(event.data()))
       return ui::DragDropTypes::DRAG_NONE;
 
     if (drop_data.index() < owner_->VisibleBrowserActions())
@@ -163,7 +163,7 @@ int BrowserActionOverflowMenuController::OnPerformDrop(
     DropPosition position,
     const views::DropTargetEvent& event) {
   BrowserActionDragData drop_data;
-  if (!drop_data.Read(event.GetData()))
+  if (!drop_data.Read(event.data()))
     return ui::DragDropTypes::DRAG_NONE;
 
   size_t drop_index;
diff --git a/chrome/browser/ui/views/extensions/extension_view.cc b/chrome/browser/ui/views/extensions/extension_view.cc
index 077f4cd..811f12e 100644
--- a/chrome/browser/ui/views/extensions/extension_view.cc
+++ b/chrome/browser/ui/views/extensions/extension_view.cc
@@ -177,7 +177,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() == ui::VKEY_TAB);
+  return (e.key_code() == ui::VKEY_TAB);
 }
 
 void ExtensionView::HandleMouseMove() {
diff --git a/chrome/browser/ui/views/find_bar_host.cc b/chrome/browser/ui/views/find_bar_host.cc
index a253f8f..c1eac91 100644
--- a/chrome/browser/ui/views/find_bar_host.cc
+++ b/chrome/browser/ui/views/find_bar_host.cc
@@ -49,7 +49,7 @@ bool FindBarHost::MaybeForwardKeyEventToWebpage(
     return false;
   }
 
-  switch (key_event.GetKeyCode()) {
+  switch (key_event.key_code()) {
     case ui::VKEY_DOWN:
     case ui::VKEY_UP:
     case ui::VKEY_PRIOR:
diff --git a/chrome/browser/ui/views/find_bar_view.cc b/chrome/browser/ui/views/find_bar_view.cc
index 92e5619..87a7abd 100644
--- a/chrome/browser/ui/views/find_bar_view.cc
+++ b/chrome/browser/ui/views/find_bar_view.cc
@@ -514,7 +514,7 @@ bool FindBarView::HandleKeyEvent(views::Textfield* sender,
   if (find_bar_host()->MaybeForwardKeyEventToWebpage(key_event))
     return true;  // Handled, we are done!
 
-  if (key_event.GetKeyCode() == ui::VKEY_RETURN) {
+  if (key_event.key_code() == ui::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/ui/views/frame/browser_root_view.cc b/chrome/browser/ui/views/frame/browser_root_view.cc
index 0eb38e3..bba2945 100644
--- a/chrome/browser/ui/views/frame/browser_root_view.cc
+++ b/chrome/browser/ui/views/frame/browser_root_view.cc
@@ -56,7 +56,7 @@ void BrowserRootView::OnDragEntered(const views::DropTargetEvent& event) {
   if (ShouldForwardToTabStrip(event)) {
     forwarding_to_tab_strip_ = true;
     scoped_ptr<views::DropTargetEvent> mapped_event(
-        MapEventToTabStrip(event, event.GetData()));
+        MapEventToTabStrip(event, event.data()));
     tabstrip()->OnDragEntered(*mapped_event.get());
   }
 }
@@ -64,7 +64,7 @@ void BrowserRootView::OnDragEntered(const views::DropTargetEvent& event) {
 int BrowserRootView::OnDragUpdated(const views::DropTargetEvent& event) {
   if (ShouldForwardToTabStrip(event)) {
     scoped_ptr<views::DropTargetEvent> mapped_event(
-        MapEventToTabStrip(event, event.GetData()));
+        MapEventToTabStrip(event, event.data()));
     if (!forwarding_to_tab_strip_) {
       tabstrip()->OnDragEntered(*mapped_event.get());
       forwarding_to_tab_strip_ = true;
@@ -94,9 +94,9 @@ int BrowserRootView::OnPerformDrop(const views::DropTargetEvent& event) {
   GURL url;
   std::wstring title;
   ui::OSExchangeData mapped_data;
-  if (!event.GetData().GetURLAndTitle(&url, &title) || !url.is_valid()) {
+  if (!event.data().GetURLAndTitle(&url, &title) || !url.is_valid()) {
     // The url isn't valid. Use the paste and go url.
-    if (GetPasteAndGoURL(event.GetData(), &url))
+    if (GetPasteAndGoURL(event.data(), &url))
       mapped_data.SetURL(url, std::wstring());
     // else case: couldn't extract a url or 'paste and go' url. This ends up
     // passing through an ui::OSExchangeData with nothing in it. We need to do
@@ -129,7 +129,7 @@ views::DropTargetEvent* BrowserRootView::MapEventToTabStrip(
   ConvertPointToView(this, tabstrip(), &tab_strip_loc);
   return new views::DropTargetEvent(data, tab_strip_loc.x(),
                                     tab_strip_loc.y(),
-                                    event.GetSourceOperations());
+                                    event.source_operations());
 }
 
 BaseTabStrip* BrowserRootView::tabstrip() const {
diff --git a/chrome/browser/ui/views/frame/browser_view.cc b/chrome/browser/ui/views/frame/browser_view.cc
index a4ab18c..3f34a24 100644
--- a/chrome/browser/ui/views/frame/browser_view.cc
+++ b/chrome/browser/ui/views/frame/browser_view.cc
@@ -1258,7 +1258,7 @@ bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
   // it'll be best if we can unify these conversion tables.
   // See http://crbug.com/54315
   views::KeyEvent views_event(event.os_event);
-  views::Accelerator accelerator(views_event.GetKeyCode(),
+  views::Accelerator accelerator(views_event.key_code(),
                                  views_event.IsShiftDown(),
                                  views_event.IsControlDown(),
                                  views_event.IsAltDown());
diff --git a/chrome/browser/ui/views/keyword_editor_view.cc b/chrome/browser/ui/views/keyword_editor_view.cc
index 38c7d30..d4ea968 100644
--- a/chrome/browser/ui/views/keyword_editor_view.cc
+++ b/chrome/browser/ui/views/keyword_editor_view.cc
@@ -258,9 +258,9 @@ void KeywordEditorView::OnDoubleClick() {
   if (edit_button_->IsEnabled()) {
     DWORD pos = GetMessagePos();
     gfx::Point cursor_point(pos);
-    views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
+    views::MouseEvent event(ui::ET_MOUSE_RELEASED,
                             cursor_point.x(), cursor_point.y(),
-                            views::Event::EF_LEFT_BUTTON_DOWN);
+                            ui::EF_LEFT_BUTTON_DOWN);
     ButtonPressed(edit_button_, event);
   }
 }
diff --git a/chrome/browser/ui/views/location_bar/location_bar_view.cc b/chrome/browser/ui/views/location_bar/location_bar_view.cc
index 6634354..8254948 100644
--- a/chrome/browser/ui/views/location_bar/location_bar_view.cc
+++ b/chrome/browser/ui/views/location_bar/location_bar_view.cc
@@ -697,13 +697,13 @@ void LocationBarView::SelectAll() {
 bool LocationBarView::OnMousePressed(const views::MouseEvent& event) {
   UINT msg;
   if (event.IsLeftMouseButton()) {
-    msg = (event.GetFlags() & views::MouseEvent::EF_IS_DOUBLE_CLICK) ?
+    msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
         WM_LBUTTONDBLCLK : WM_LBUTTONDOWN;
   } else if (event.IsMiddleMouseButton()) {
-    msg = (event.GetFlags() & views::MouseEvent::EF_IS_DOUBLE_CLICK) ?
+    msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
         WM_MBUTTONDBLCLK : WM_MBUTTONDOWN;
   } else if (event.IsRightMouseButton()) {
-    msg = (event.GetFlags() & views::MouseEvent::EF_IS_DOUBLE_CLICK) ?
+    msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
         WM_RBUTTONDBLCLK : WM_RBUTTONDOWN;
   } else {
     NOTREACHED();
diff --git a/chrome/browser/ui/views/location_bar/page_action_image_view.cc b/chrome/browser/ui/views/location_bar/page_action_image_view.cc
index e867091..bcfe51a 100644
--- a/chrome/browser/ui/views/location_bar/page_action_image_view.cc
+++ b/chrome/browser/ui/views/location_bar/page_action_image_view.cc
@@ -140,8 +140,7 @@ void PageActionImageView::OnMouseReleased(const views::MouseEvent& event,
 }
 
 bool PageActionImageView::OnKeyPressed(const views::KeyEvent& e) {
-  if (e.GetKeyCode() == ui::VKEY_SPACE ||
-      e.GetKeyCode() == ui::VKEY_RETURN) {
+  if (e.key_code() == ui::VKEY_SPACE || e.key_code() == ui::VKEY_RETURN) {
     ExecuteAction(1, false);
     return true;
   }
diff --git a/chrome/browser/ui/views/location_bar/star_view.cc b/chrome/browser/ui/views/location_bar/star_view.cc
index c7bacbeb..886aec2 100644
--- a/chrome/browser/ui/views/location_bar/star_view.cc
+++ b/chrome/browser/ui/views/location_bar/star_view.cc
@@ -59,8 +59,7 @@ void StarView::OnMouseReleased(const views::MouseEvent& event, bool canceled) {
 }
 
 bool StarView::OnKeyPressed(const views::KeyEvent& e) {
-  if (e.GetKeyCode() == ui::VKEY_SPACE ||
-      e.GetKeyCode() == ui::VKEY_RETURN) {
+  if (e.key_code() == ui::VKEY_SPACE || e.key_code() == ui::VKEY_RETURN) {
     command_updater_->ExecuteCommand(IDC_BOOKMARK_PAGE);
     return true;
   }
diff --git a/chrome/browser/ui/views/options/cookies_view.cc b/chrome/browser/ui/views/options/cookies_view.cc
index 83040e5..5b9c9e3 100644
--- a/chrome/browser/ui/views/options/cookies_view.cc
+++ b/chrome/browser/ui/views/options/cookies_view.cc
@@ -145,9 +145,9 @@ void CookiesView::ContentsChanged(views::Textfield* sender,
 
 bool CookiesView::HandleKeyEvent(views::Textfield* sender,
                                  const views::KeyEvent& key_event) {
-  if (key_event.GetKeyCode() == ui::VKEY_ESCAPE) {
+  if (key_event.key_code() == ui::VKEY_ESCAPE) {
     ResetSearchQuery();
-  } else if (key_event.GetKeyCode() == ui::VKEY_RETURN) {
+  } else if (key_event.key_code() == ui::VKEY_RETURN) {
     search_update_factory_.RevokeAll();
     UpdateSearchResults();
   }
diff --git a/chrome/browser/ui/views/reload_button.cc b/chrome/browser/ui/views/reload_button.cc
index 80a469a..4189dd1 100644
--- a/chrome/browser/ui/views/reload_button.cc
+++ b/chrome/browser/ui/views/reload_button.cc
@@ -83,7 +83,7 @@ void ReloadButton::ButtonPressed(views::Button* /* button */,
     if (event.IsShiftDown() || event.IsControlDown()) {
       command = IDC_RELOAD_IGNORING_CACHE;
       // Mask off Shift and Control so they don't affect the disposition below.
-      flags &= ~(views::Event::EF_SHIFT_DOWN | views::Event::EF_CONTROL_DOWN);
+      flags &= ~(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN);
     } else {
       command = IDC_RELOAD;
     }
diff --git a/chrome/browser/ui/views/reload_button_unittest.cc b/chrome/browser/ui/views/reload_button_unittest.cc
index db0d616..2f1aab00 100644
--- a/chrome/browser/ui/views/reload_button_unittest.cc
+++ b/chrome/browser/ui/views/reload_button_unittest.cc
@@ -57,7 +57,7 @@ TEST_F(ReloadButtonTest, Basic) {
              false);
 
   // Press the button.  This should start the double-click timer.
-  views::MouseEvent e(views::Event::ET_MOUSE_PRESSED, 0, 0, 0);
+  views::MouseEvent e(ui::ET_MOUSE_PRESSED, 0, 0, 0);
   reload_.ButtonPressed(&reload_, e);
   CheckState(true, ReloadButton::MODE_RELOAD, ReloadButton::MODE_RELOAD, true,
              false);
@@ -76,7 +76,7 @@ TEST_F(ReloadButtonTest, Basic) {
 
 TEST_F(ReloadButtonTest, DoubleClickTimer) {
   // Start by pressing the button.
-  views::MouseEvent e(views::Event::ET_MOUSE_PRESSED, 0, 0, 0);
+  views::MouseEvent e(ui::ET_MOUSE_PRESSED, 0, 0, 0);
   reload_.ButtonPressed(&reload_, e);
 
   // Try to press the button again.  This should do nothing because the timer is
@@ -102,7 +102,7 @@ TEST_F(ReloadButtonTest, DoubleClickTimer) {
 
 TEST_F(ReloadButtonTest, DisableOnHover) {
   // Change to stop and hover.
-  views::MouseEvent e(views::Event::ET_MOUSE_PRESSED, 0, 0, 0);
+  views::MouseEvent e(ui::ET_MOUSE_PRESSED, 0, 0, 0);
   reload_.ButtonPressed(&reload_, e);
   reload_.ChangeMode(ReloadButton::MODE_STOP, false);
   set_mouse_hovered(true);
@@ -115,7 +115,7 @@ TEST_F(ReloadButtonTest, DisableOnHover) {
 
   // Un-hover the button, which should allow it to reset.
   set_mouse_hovered(false);
-  views::MouseEvent e2(views::Event::ET_MOUSE_MOVED, 0, 0, 0);
+  views::MouseEvent e2(ui::ET_MOUSE_MOVED, 0, 0, 0);
   reload_.OnMouseExited(e2);
   CheckState(true, ReloadButton::MODE_RELOAD, ReloadButton::MODE_RELOAD, false,
              false);
@@ -123,7 +123,7 @@ TEST_F(ReloadButtonTest, DisableOnHover) {
 
 TEST_F(ReloadButtonTest, ResetOnClick) {
   // Change to stop and hover.
-  views::MouseEvent e(views::Event::ET_MOUSE_PRESSED, 0, 0, 0);
+  views::MouseEvent e(ui::ET_MOUSE_PRESSED, 0, 0, 0);
   reload_.ButtonPressed(&reload_, e);
   reload_.ChangeMode(ReloadButton::MODE_STOP, false);
   set_mouse_hovered(true);
@@ -137,7 +137,7 @@ TEST_F(ReloadButtonTest, ResetOnClick) {
 
 TEST_F(ReloadButtonTest, ResetOnTimer) {
   // Change to stop, hover, and change back to reload.
-  views::MouseEvent e(views::Event::ET_MOUSE_PRESSED, 0, 0, 0);
+  views::MouseEvent e(ui::ET_MOUSE_PRESSED, 0, 0, 0);
   reload_.ButtonPressed(&reload_, e);
   reload_.ChangeMode(ReloadButton::MODE_STOP, false);
   set_mouse_hovered(true);
diff --git a/chrome/browser/ui/views/tabs/tab_dragging_test.cc b/chrome/browser/ui/views/tabs/tab_dragging_test.cc
index 5830deb..d39b3ff 100644
--- a/chrome/browser/ui/views/tabs/tab_dragging_test.cc
+++ b/chrome/browser/ui/views/tabs/tab_dragging_test.cc
@@ -134,7 +134,7 @@ TEST_F(TabDraggingTest, MAYBE_Tab1Tab2) {
                    bounds1.y() + bounds1.height() / 2);
   gfx::Point end(start.x() + 2 * bounds1.width() / 3, start.y());
   ASSERT_TRUE(browser->SimulateDrag(start, end,
-                                    views::Event::EF_LEFT_BUTTON_DOWN,
+                                    ui::EF_LEFT_BUTTON_DOWN,
                                     false));
 
   // Now check for expected results.
@@ -234,7 +234,7 @@ TEST_F(TabDraggingTest, MAYBE_Tab1Tab3) {
                      bounds3.width() / 2,
                  start.y());
   ASSERT_TRUE(browser->SimulateDrag(start, end,
-                                    views::Event::EF_LEFT_BUTTON_DOWN,
+                                    ui::EF_LEFT_BUTTON_DOWN,
                                     false));
 
   // Now check for expected results.
@@ -344,7 +344,7 @@ TEST_F(TabDraggingTest, MAYBE_Tab1Tab3Escape) {
   // Simulate drag with 'true' as the last parameter. This will interrupt
   // in-flight with Escape.
   ASSERT_TRUE(browser->SimulateDrag(start, end,
-                                    views::Event::EF_LEFT_BUTTON_DOWN,
+                                    ui::EF_LEFT_BUTTON_DOWN,
                                     true));
 
   // Now check for expected results.
@@ -465,7 +465,7 @@ TEST_F(TabDraggingTest, MAYBE_Tab2OutOfTabStrip) {
 
   // Simulate tab drag.
   ASSERT_TRUE(browser->SimulateDrag(start, end,
-                                    views::Event::EF_LEFT_BUTTON_DOWN,
+                                    ui::EF_LEFT_BUTTON_DOWN,
                                     false));
 
   // Now, first make sure that the old window has only two tabs remaining.
diff --git a/chrome/browser/ui/views/tabs/tab_strip.cc b/chrome/browser/ui/views/tabs/tab_strip.cc
index eca1ef9..84d7517 100644
--- a/chrome/browser/ui/views/tabs/tab_strip.cc
+++ b/chrome/browser/ui/views/tabs/tab_strip.cc
@@ -355,7 +355,7 @@ int TabStrip::OnPerformDrop(const DropTargetEvent& event) {
 
   GURL url;
   std::wstring title;
-  if (!event.GetData().GetURLAndTitle(&url, &title) || !url.is_valid())
+  if (!event.data().GetURLAndTitle(&url, &title) || !url.is_valid())
     return ui::DragDropTypes::DRAG_NONE;
 
   controller()->PerformDrop(drop_before, drop_index, url);
@@ -758,7 +758,7 @@ void TabStrip::SetDropIndex(int tab_data_index, bool drop_before) {
 }
 
 int TabStrip::GetDropEffect(const views::DropTargetEvent& event) {
-  const int source_ops = event.GetSourceOperations();
+  const int source_ops = event.source_operations();
   if (source_ops & ui::DragDropTypes::DRAG_COPY)
     return ui::DragDropTypes::DRAG_COPY;
   if (source_ops & ui::DragDropTypes::DRAG_LINK)
diff --git a/chrome/browser/ui/views/toolbar_view.cc b/chrome/browser/ui/views/toolbar_view.cc
index c3aa37f..dde2083 100644
--- a/chrome/browser/ui/views/toolbar_view.cc
+++ b/chrome/browser/ui/views/toolbar_view.cc
@@ -146,8 +146,8 @@ void ToolbarView::Init(Profile* profile) {
   }
 #endif
   back_ = new views::ButtonDropDown(this, back_menu_model_.get());
-  back_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
-                                     views::Event::EF_MIDDLE_BUTTON_DOWN);
+  back_->set_triggerable_event_flags(ui::EF_LEFT_BUTTON_DOWN |
+                                     ui::EF_MIDDLE_BUTTON_DOWN);
   back_->set_tag(IDC_BACK);
   back_->SetImageAlignment(views::ImageButton::ALIGN_RIGHT,
                            views::ImageButton::ALIGN_TOP);
@@ -157,8 +157,8 @@ void ToolbarView::Init(Profile* profile) {
   back_->SetID(VIEW_ID_BACK_BUTTON);
 
   forward_ = new views::ButtonDropDown(this, forward_menu_model_.get());
-  forward_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
-                                        views::Event::EF_MIDDLE_BUTTON_DOWN);
+  forward_->set_triggerable_event_flags(ui::EF_LEFT_BUTTON_DOWN |
+                                        ui::EF_MIDDLE_BUTTON_DOWN);
   forward_->set_tag(IDC_FORWARD);
   forward_->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_TOOLTIP_FORWARD)));
@@ -171,8 +171,8 @@ void ToolbarView::Init(Profile* profile) {
           LocationBarView::POPUP : LocationBarView::NORMAL);
 
   reload_ = new ReloadButton(location_bar_, browser_);
-  reload_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
-                                       views::Event::EF_MIDDLE_BUTTON_DOWN);
+  reload_->set_triggerable_event_flags(ui::EF_LEFT_BUTTON_DOWN |
+                                       ui::EF_MIDDLE_BUTTON_DOWN);
   reload_->set_tag(IDC_RELOAD);
   reload_->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_TOOLTIP_RELOAD)));
@@ -182,8 +182,8 @@ void ToolbarView::Init(Profile* profile) {
 #if defined(OS_CHROMEOS)
   feedback_ = new views::ImageButton(this);
   feedback_->set_tag(IDC_FEEDBACK);
-  feedback_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
-                                         views::Event::EF_MIDDLE_BUTTON_DOWN);
+  feedback_->set_triggerable_event_flags(ui::EF_LEFT_BUTTON_DOWN |
+                                         ui::EF_MIDDLE_BUTTON_DOWN);
   feedback_->set_tag(IDC_FEEDBACK);
   feedback_->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_TOOLTIP_FEEDBACK)));
@@ -191,8 +191,8 @@ void ToolbarView::Init(Profile* profile) {
 #endif
 
   home_ = new views::ImageButton(this);
-  home_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
-                                     views::Event::EF_MIDDLE_BUTTON_DOWN);
+  home_->set_triggerable_event_flags(ui::EF_LEFT_BUTTON_DOWN |
+                                     ui::EF_MIDDLE_BUTTON_DOWN);
   home_->set_tag(IDC_HOME);
   home_->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_TOOLTIP_HOME)));
diff --git a/chrome/browser/unload_uitest.cc b/chrome/browser/unload_uitest.cc
index ed32d6c..84f0e4f 100644
--- a/chrome/browser/unload_uitest.cc
+++ b/chrome/browser/unload_uitest.cc
@@ -12,8 +12,8 @@
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "net/url_request/url_request_test_util.h"
+#include "ui/base/events.h"
 #include "ui/base/message_box_flags.h"
-#include "views/events/event.h"
 
 const std::string NOLISTENERS_HTML =
     "<html><head><title>nolisteners</title></head><body></body></html>";
@@ -245,7 +245,7 @@ TEST_F(UnloadTest, MAYBE_CrossSiteInfiniteUnloadAsyncInputEvent) {
   gfx::Rect bounds;
   ASSERT_TRUE(window->GetViewBounds(VIEW_ID_TAB_0, &bounds, false));
   ASSERT_TRUE(browser->SimulateDrag(bounds.CenterPoint(), bounds.CenterPoint(),
-                                    views::Event::EF_LEFT_BUTTON_DOWN, false));
+                                    ui::EF_LEFT_BUTTON_DOWN, false));
 
   // The title should update before the timeout in CheckTitle.
   CheckTitle(L"Title Of Awesomeness");
@@ -437,7 +437,7 @@ TEST_F(UnloadTest, MAYBE_BrowserCloseTabWhenOtherTabHasListener) {
   // Simulate a click to force user_gesture to true; if we don't, the resulting
   // popup will be constrained, which isn't what we want to test.
   ASSERT_TRUE(window->SimulateOSClick(tab_view_bounds.CenterPoint(),
-                                      views::Event::EF_LEFT_BUTTON_DOWN));
+                                      ui::EF_LEFT_BUTTON_DOWN));
   ASSERT_TRUE(browser->WaitForTabCountToBecome(2));
 
   scoped_refptr<TabProxy> popup_tab(browser->GetActiveTab());
diff --git a/chrome/test/automated_ui_tests/automated_ui_test_base.cc b/chrome/test/automated_ui_tests/automated_ui_test_base.cc
index f5cad88..e282256 100644
--- a/chrome/test/automated_ui_tests/automated_ui_test_base.cc
+++ b/chrome/test/automated_ui_tests/automated_ui_test_base.cc
@@ -10,9 +10,9 @@
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
+#include "ui/base/events.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
-#include "views/events/event.h"
 
 AutomatedUITestBase::AutomatedUITestBase() {}
 
@@ -139,8 +139,7 @@ bool AutomatedUITestBase::DragTabOut() {
   end.set_x(start.x());
   end.set_y(start.y() + 3 * urlbar_bounds.height());
 
-  if (!browser->SimulateDrag(start, end, views::Event::EF_LEFT_BUTTON_DOWN,
-                             false)) {
+  if (!browser->SimulateDrag(start, end, ui::EF_LEFT_BUTTON_DOWN, false)) {
     LogWarningMessage("failed_to_simulate_drag");
     return false;
   }
@@ -208,7 +207,7 @@ bool AutomatedUITestBase::DragActiveTab(bool drag_right) {
   }
 
   if (!browser->SimulateDrag(dragged_tab_point, destination_point,
-                             views::Event::EF_LEFT_BUTTON_DOWN, false)) {
+                             ui::EF_LEFT_BUTTON_DOWN, false)) {
     LogWarningMessage("failed_to_simulate_drag");
     return false;
   }
diff --git a/chrome/test/automation/automation_proxy_uitest.cc b/chrome/test/automation/automation_proxy_uitest.cc
index 9286459..cd34c8f 100644
--- a/chrome/test/automation/automation_proxy_uitest.cc
+++ b/chrome/test/automation/automation_proxy_uitest.cc
@@ -43,7 +43,6 @@
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect.h"
-#include "views/events/event.h"
 
 using ui_test_utils::TimedMessageLoopRunner;
 using testing::CreateFunctor;
@@ -191,8 +190,7 @@ TEST_F(AutomationProxyVisibleTest, MAYBE_WindowGetViewBounds) {
     start.y = bounds.y() + bounds.height() / 2;
     end.x = start.x + 2 * bounds.width() / 3;
     end.y = start.y;
-    ASSERT_TRUE(browser->SimulateDrag(start, end,
-                                      views::Event::EF_LEFT_BUTTON_DOWN));
+    ASSERT_TRUE(browser->SimulateDrag(start, end, ui::EF_LEFT_BUTTON_DOWN));
 
     // Check to see that the drag event successfully swapped the two tabs.
     tab1 = browser->GetTab(0);
diff --git a/chrome/test/interactive_ui/fast_shutdown_interactive_uitest.cc b/chrome/test/interactive_ui/fast_shutdown_interactive_uitest.cc
index c14cbd3..15a0ab8 100644
--- a/chrome/test/interactive_ui/fast_shutdown_interactive_uitest.cc
+++ b/chrome/test/interactive_ui/fast_shutdown_interactive_uitest.cc
@@ -11,9 +11,9 @@
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "chrome/test/ui_test_utils.h"
+#include "ui/base/events.h"
 #include "ui/base/message_box_flags.h"
 #include "ui/gfx/rect.h"
-#include "views/events/event.h"
 
 class FastShutdown : public UITest {
 };
@@ -42,7 +42,7 @@ TEST_F(FastShutdown, MAYBE_SlowTermination) {
   ASSERT_TRUE(window->GetViewBounds(VIEW_ID_TAB_CONTAINER, &bounds, true));
   // This click will launch a popup which has a before unload handler.
   ASSERT_TRUE(window->SimulateOSClick(bounds.CenterPoint(),
-                                      views::Event::EF_LEFT_BUTTON_DOWN));
+                                      ui::EF_LEFT_BUTTON_DOWN));
   ASSERT_TRUE(browser->WaitForTabCountToBecome(2));
   // Close the tab, removing the one and only before unload handler.
   scoped_refptr<TabProxy> tab(browser->GetTab(1));
diff --git a/chrome/test/interactive_ui/keyboard_access_uitest.cc b/chrome/test/interactive_ui/keyboard_access_uitest.cc
index 8bf28d0..5a9e089 100644
--- a/chrome/test/interactive_ui/keyboard_access_uitest.cc
+++ b/chrome/test/interactive_ui/keyboard_access_uitest.cc
@@ -8,8 +8,8 @@
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "googleurl/src/gurl.h"
+#include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
-#include "views/events/event.h"
 
 // This functionality currently works on Windows and on Linux when
 // toolkit_views is defined (i.e. for Chrome OS). It's not needed
@@ -118,7 +118,7 @@ TEST_F(KeyboardAccessTest, DISABLED_TestAltMenuKeyboardAccess) {
 
 // Flaky, http://crbug.com/62311.
 TEST_F(KeyboardAccessTest, FLAKY_TestShiftAltMenuKeyboardAccess) {
-  TestMenuKeyboardAccess(true, views::Event::EF_SHIFT_DOWN);
+  TestMenuKeyboardAccess(true, ui::EF_SHIFT_DOWN);
 }
 
 #if defined(OS_CHROMEOS)
@@ -154,14 +154,13 @@ TEST_F(KeyboardAccessTest, MAYBE_ReserveKeyboardAccelerators) {
   scoped_refptr<WindowProxy> window(browser->GetWindow());
   ASSERT_TRUE(window);
   ASSERT_TRUE(window->SimulateOSKeyPress(
-      ui::VKEY_TAB, views::Event::EF_CONTROL_DOWN));
+      ui::VKEY_TAB, ui::EF_CONTROL_DOWN));
   ASSERT_TRUE(browser->WaitForTabToBecomeActive(
       0, TestTimeouts::action_max_timeout_ms()));
 
 #if !defined(OS_MACOSX)  // see BrowserWindowCocoa::GetCommandId
   ASSERT_TRUE(browser->ActivateTab(1));
-  ASSERT_TRUE(window->SimulateOSKeyPress(
-      ui::VKEY_F4, views::Event::EF_CONTROL_DOWN));
+  ASSERT_TRUE(window->SimulateOSKeyPress(ui::VKEY_F4, ui::EF_CONTROL_DOWN));
   ASSERT_TRUE(browser->WaitForTabCountToBecome(1));
 #endif
 }
diff --git a/chrome/test/ui/history_uitest.cc b/chrome/test/ui/history_uitest.cc
index d7d29f0..a7f0e14 100644
--- a/chrome/test/ui/history_uitest.cc
+++ b/chrome/test/ui/history_uitest.cc
@@ -12,8 +12,8 @@
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "chrome/test/ui_test_utils.h"
+#include "ui/base/events.h"
 #include "ui/gfx/rect.h"
-#include "views/events/event.h"
 
 namespace {
 
@@ -109,9 +109,8 @@ TEST_F(HistoryTester, ConsiderRedirectAfterGestureAsUserInitiated) {
   gfx::Rect tab_view_bounds;
   ASSERT_TRUE(window->GetViewBounds(VIEW_ID_TAB_CONTAINER, &tab_view_bounds,
                                     true));
-  ASSERT_TRUE(
-      window->SimulateOSClick(tab_view_bounds.CenterPoint(),
-                              views::Event::EF_LEFT_BUTTON_DOWN));
+  ASSERT_TRUE(window->SimulateOSClick(tab_view_bounds.CenterPoint(),
+                                      ui::EF_LEFT_BUTTON_DOWN));
 
   NavigateToURL(GURL("javascript:redirectToPage12()"));
   WaitForFinish("History_Length_Test_12", "1", url, kTestCompleteCookie,
diff --git a/chrome/test/webdriver/commands/webdriver_command.cc b/chrome/test/webdriver/commands/webdriver_command.cc
index d1d0a73..cc0e471 100644
--- a/chrome/test/webdriver/commands/webdriver_command.cc
+++ b/chrome/test/webdriver/commands/webdriver_command.cc
@@ -19,7 +19,6 @@
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/webdriver/utility_functions.h"
-#include "views/events/event.h"
 
 namespace webdriver {
 
diff --git a/chrome/test/webdriver/keymap.cc b/chrome/test/webdriver/keymap.cc
index c3080d7..91b0e07 100644
--- a/chrome/test/webdriver/keymap.cc
+++ b/chrome/test/webdriver/keymap.cc
@@ -5,7 +5,7 @@
 #include "chrome/test/webdriver/keymap.h"
 
 #include "chrome/browser/automation/ui_controls.h"
-#include "views/events/event.h"
+#include "ui/base/events.h"
 
 namespace webdriver {
 
@@ -147,17 +147,17 @@ bool KeyMap::Press(const scoped_refptr<WindowProxy>& window,
 
   int modifiers = 0;
   if (shift_ || shifted_keys_.find(key) != shifted_keys_.end()) {
-    modifiers = modifiers | views::Event::EF_SHIFT_DOWN;
+    modifiers = modifiers | ui::EF_SHIFT_DOWN;
   }
   if (control_) {
-    modifiers = modifiers | views::Event::EF_CONTROL_DOWN;
+    modifiers = modifiers | ui::EF_CONTROL_DOWN;
   }
   if (alt_) {
-    modifiers = modifiers | views::Event::EF_ALT_DOWN;
+    modifiers = modifiers | ui::EF_ALT_DOWN;
   }
   if (command_) {
     VLOG(1) << "Pressing command key on linux!!";
-    modifiers = modifiers | views::Event::EF_COMMAND_DOWN;
+    modifiers = modifiers | ui::EF_COMMAND_DOWN;
   }
 
   // TODO(jmikhail): need to be able to capture modifier key up.
diff --git a/ui/base/events.h b/ui/base/events.h
new file mode 100644
index 0000000..0a3f875
--- /dev/null
+++ b/ui/base/events.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2011 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 UI_BASE_EVENTS_H_
+#define UI_BASE_EVENTS_H_
+#pragma once
+
+namespace ui {
+
+// Event types. (prefixed because of a conflict with windows headers)
+enum EventType {
+  ET_UNKNOWN = 0,
+  ET_MOUSE_PRESSED,
+  ET_MOUSE_DRAGGED,
+  ET_MOUSE_RELEASED,
+  ET_MOUSE_MOVED,
+  ET_MOUSE_ENTERED,
+  ET_MOUSE_EXITED,
+  ET_KEY_PRESSED,
+  ET_KEY_RELEASED,
+  ET_MOUSEWHEEL,
+#if defined(TOUCH_UI)
+  ET_TOUCH_RELEASED,
+  ET_TOUCH_PRESSED,
+  ET_TOUCH_MOVED,
+  ET_TOUCH_STATIONARY,
+  ET_TOUCH_CANCELLED,
+#endif
+  ET_DROP_TARGET_EVENT
+};
+
+// Event flags currently supported.  Although this is a "views"
+// file, this header is used on non-views platforms (e.g. OSX).  For
+// example, these EventFlags are used by the automation provider for
+// all platforms.
+enum EventFlags {
+  EF_CAPS_LOCK_DOWN     = 1 << 0,
+  EF_SHIFT_DOWN         = 1 << 1,
+  EF_CONTROL_DOWN       = 1 << 2,
+  EF_ALT_DOWN           = 1 << 3,
+  EF_LEFT_BUTTON_DOWN   = 1 << 4,
+  EF_MIDDLE_BUTTON_DOWN = 1 << 5,
+  EF_RIGHT_BUTTON_DOWN  = 1 << 6,
+  EF_COMMAND_DOWN       = 1 << 7,  // Only useful on OSX
+};
+
+// Flags specific to mouse events
+enum MouseEventFlags {
+  EF_IS_DOUBLE_CLICK    = 1 << 16,
+  EF_IS_NON_CLIENT      = 1 << 17
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_EVENTS_H_
+
diff --git a/ui/views/events/event_win.cc b/ui/views/events/event_win.cc
index 10a4b55..15d92009 100644
--- a/ui/views/events/event_win.cc
+++ b/ui/views/events/event_win.cc
@@ -19,30 +19,30 @@ namespace {
 int GetKeyStateFlags() {
   int flags = 0;
   if (GetKeyState(VK_MENU) & 0x80)
-    flags |= Event::EF_ALT_DOWN;
+    flags |= ui::EF_ALT_DOWN;
   if (GetKeyState(VK_SHIFT) & 0x80)
-    flags |= Event::EF_SHIFT_DOWN;
+    flags |= ui::EF_SHIFT_DOWN;
   if (GetKeyState(VK_CONTROL) & 0x80)
-    flags |= Event::EF_CONTROL_DOWN;
+    flags |= ui::EF_CONTROL_DOWN;
   return flags;
 }
 
 // Convert windows message identifiers to Event types.
-Event::EventType EventTypeFromNative(NativeEvent native_event) {
+ui::EventType EventTypeFromNative(NativeEvent native_event) {
   switch (native_event.message) {
     case WM_KEYDOWN:
     case WM_SYSKEYDOWN:
-      return Event::ET_KEY_PRESSED;
+      return ui::ET_KEY_PRESSED;
     case WM_KEYUP:
     case WM_SYSKEYUP:
-      return Event::ET_KEY_RELEASED;
+      return ui::ET_KEY_RELEASED;
     case WM_LBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_NCLBUTTONDOWN:
     case WM_NCMBUTTONDOWN:
     case WM_NCRBUTTONDOWN:
     case WM_RBUTTONDOWN:
-      return Event::ET_MOUSE_PRESSED;
+      return ui::ET_MOUSE_PRESSED;
     case WM_LBUTTONDBLCLK:
     case WM_LBUTTONUP:
     case WM_MBUTTONDBLCLK:
@@ -55,19 +55,19 @@ Event::EventType EventTypeFromNative(NativeEvent native_event) {
     case WM_NCRBUTTONUP:
     case WM_RBUTTONDBLCLK:
     case WM_RBUTTONUP:
-      return Event::ET_MOUSE_RELEASED;
+      return ui::ET_MOUSE_RELEASED;
     case WM_MOUSEMOVE:
     case WM_NCMOUSEMOVE:
-      return Event::ET_MOUSE_MOVED;
+      return ui::ET_MOUSE_MOVED;
     case WM_MOUSEWHEEL:
-      return Event::ET_MOUSEWHEEL;
+      return ui::ET_MOUSEWHEEL;
     case WM_MOUSELEAVE:
     case WM_NCMOUSELEAVE:
-      return Event::ET_MOUSE_EXITED;
+      return ui::ET_MOUSE_EXITED;
     default:
       NOTREACHED();
   }
-  return Event::ET_UNKNOWN;
+  return ui::ET_UNKNOWN;
 }
 
 bool IsClientMouseEvent(NativeEvent native_event) {
@@ -102,7 +102,7 @@ int MouseEventFlagsFromNative(NativeEvent native_event) {
 
   // Check if the event occurred in the non-client area.
   if (IsNonClientMouseEvent(native_event))
-    flags |= MouseEvent::EF_IS_NON_CLIENT;
+    flags |= ui::EF_IS_NON_CLIENT;
 
   // Check for double click events.
   switch (native_event.message) {
@@ -112,28 +112,28 @@ int MouseEventFlagsFromNative(NativeEvent native_event) {
     case WM_LBUTTONDBLCLK:
     case WM_MBUTTONDBLCLK:
     case WM_RBUTTONDBLCLK:
-      flags |= MouseEvent::EF_IS_DOUBLE_CLICK;
+      flags |= ui::EF_IS_DOUBLE_CLICK;
       break;
   }
 
   // Check for pressed buttons.
   if (IsClientMouseEvent(native_event)) {
     if (native_event.wParam & MK_LBUTTON)
-      flags |= Event::EF_LEFT_BUTTON_DOWN;
+      flags |= ui::EF_LEFT_BUTTON_DOWN;
     if (native_event.wParam & MK_MBUTTON)
-      flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+      flags |= ui::EF_MIDDLE_BUTTON_DOWN;
     if (native_event.wParam & MK_RBUTTON)
-      flags |= Event::EF_RIGHT_BUTTON_DOWN;
+      flags |= ui::EF_RIGHT_BUTTON_DOWN;
   } else if (IsNonClientMouseEvent(native_event)) {
     switch (native_event.message) {
       case WM_NCLBUTTONDOWN:
-        flags |= Event::EF_LEFT_BUTTON_DOWN;
+        flags |= ui::EF_LEFT_BUTTON_DOWN;
         break;
       case WM_NCMBUTTONDOWN:
-        flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+        flags |= ui::EF_MIDDLE_BUTTON_DOWN;
         break;
       case WM_NCRBUTTONDOWN:
-        flags |= Event::EF_RIGHT_BUTTON_DOWN;
+        flags |= ui::EF_RIGHT_BUTTON_DOWN;
         break;
     }
   }
@@ -146,17 +146,17 @@ int MouseWheelEventFlagsFromNative(NativeEvent native_event) {
   int native_flags = GET_KEYSTATE_WPARAM(native_event.wParam);
   int flags = 0;
   if (native_flags & MK_CONTROL)
-    flags |= Event::EF_CONTROL_DOWN;
+    flags |= ui::EF_CONTROL_DOWN;
   if (native_flags & MK_SHIFT)
-    flags |= Event::EF_SHIFT_DOWN;
+    flags |= ui::EF_SHIFT_DOWN;
   if (GetKeyState(VK_MENU) < 0)
-    flags |= Event::EF_ALT_DOWN;
+    flags |= ui::EF_ALT_DOWN;
   if (native_flags & MK_LBUTTON)
-    flags |= Event::EF_LEFT_BUTTON_DOWN;
+    flags |= ui::EF_LEFT_BUTTON_DOWN;
   if (native_flags & MK_MBUTTON)
-    flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+    flags |= ui::EF_MIDDLE_BUTTON_DOWN;
   if (native_flags & MK_RBUTTON)
-    flags |= Event::EF_RIGHT_BUTTON_DOWN;
+    flags |= ui::EF_RIGHT_BUTTON_DOWN;
   return flags;
 }
 
diff --git a/ui/views/widget/widget.cc b/ui/views/widget/widget.cc
index 6fb70b3..a03e9ff 100644
--- a/ui/views/widget/widget.cc
+++ b/ui/views/widget/widget.cc
@@ -161,7 +161,7 @@ void Widget::OnMouseCaptureLost() {
 bool Widget::OnMouseEvent(const MouseEvent& event) {
   last_mouse_event_was_move_ = false;
   switch (event.type()) {
-    case Event::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_PRESSED:
       if (root_view_->OnMousePressed(event)) {
         is_mouse_button_pressed_ = true;
         if (!native_widget_->HasMouseCapture())
@@ -169,7 +169,7 @@ bool Widget::OnMouseEvent(const MouseEvent& event) {
         return true;
       }
       return false;
-    case Event::ET_MOUSE_RELEASED:
+    case ui::ET_MOUSE_RELEASED:
       // TODO(beng): NativeWidgetGtk should not call this function if drag data
       //             exists, see comment in this function in WidgetGtk.
       // Release the capture first, that way we don't get confused if
@@ -181,7 +181,7 @@ bool Widget::OnMouseEvent(const MouseEvent& event) {
       is_mouse_button_pressed_ = false;
       root_view_->OnMouseReleased(event);
       return true;
-    case Event::ET_MOUSE_MOVED:
+    case ui::ET_MOUSE_MOVED:
       if (native_widget_->HasMouseCapture() && is_mouse_button_pressed_) {
         last_mouse_event_was_move_ = false;
         root_view_->OnMouseDragged(event);
@@ -198,7 +198,7 @@ bool Widget::OnMouseEvent(const MouseEvent& event) {
         root_view_->OnMouseMoved(event);
       }
       break;
-    case Event::ET_MOUSE_EXITED:
+    case ui::ET_MOUSE_EXITED:
       root_view_->OnMouseExited(event);
       return true;
   }
diff --git a/views/accelerator.h b/views/accelerator.h
index b399efc..a6cbaf4 100644
--- a/views/accelerator.h
+++ b/views/accelerator.h
@@ -32,25 +32,25 @@ class Accelerator : public ui::Accelerator {
     key_code_ = keycode;
     modifiers_ = 0;
     if (shift_pressed)
-      modifiers_ |= Event::EF_SHIFT_DOWN;
+      modifiers_ |= ui::EF_SHIFT_DOWN;
     if (ctrl_pressed)
-      modifiers_ |= Event::EF_CONTROL_DOWN;
+      modifiers_ |= ui::EF_CONTROL_DOWN;
     if (alt_pressed)
-      modifiers_ |= Event::EF_ALT_DOWN;
+      modifiers_ |= ui::EF_ALT_DOWN;
   }
 
   virtual ~Accelerator() {}
 
   bool IsShiftDown() const {
-    return (modifiers_ & Event::EF_SHIFT_DOWN) == Event::EF_SHIFT_DOWN;
+    return (modifiers_ & ui::EF_SHIFT_DOWN) == ui::EF_SHIFT_DOWN;
   }
 
   bool IsCtrlDown() const {
-    return (modifiers_ & Event::EF_CONTROL_DOWN) == Event::EF_CONTROL_DOWN;
+    return (modifiers_ & ui::EF_CONTROL_DOWN) == ui::EF_CONTROL_DOWN;
   }
 
   bool IsAltDown() const {
-    return (modifiers_ & Event::EF_ALT_DOWN) == Event::EF_ALT_DOWN;
+    return (modifiers_ & ui::EF_ALT_DOWN) == ui::EF_ALT_DOWN;
   }
 
   // Returns a string with the localized shortcut if any.
diff --git a/views/controls/button/button.cc b/views/controls/button/button.cc
index b59fd89..7b6cc75 100644
--- a/views/controls/button/button.cc
+++ b/views/controls/button/button.cc
@@ -52,7 +52,7 @@ Button::Button(ButtonListener* listener)
 }
 
 void Button::NotifyClick(const views::Event& event) {
-  mouse_event_flags_ = event.IsMouseEvent() ? event.GetFlags() : 0;
+  mouse_event_flags_ = event.IsMouseEvent() ? event.flags() : 0;
   // We can be called when there is no listener, in cases like double clicks on
   // menu buttons etc.
   if (listener_)
diff --git a/views/controls/button/button_dropdown.cc b/views/controls/button/button_dropdown.cc
index 16f424f..d2f69e2 100644
--- a/views/controls/button/button_dropdown.cc
+++ b/views/controls/button/button_dropdown.cc
@@ -123,8 +123,8 @@ void ButtonDropDown::ShowContextMenu(const gfx::Point& p,
 bool ButtonDropDown::ShouldEnterPushedState(const MouseEvent& e) {
   // Enter PUSHED state on press with Left or Right mouse button. Remain
   // in this state while the context menu is open.
-  return ((MouseEvent::EF_LEFT_BUTTON_DOWN |
-    MouseEvent::EF_RIGHT_BUTTON_DOWN) & e.GetFlags()) != 0;
+  return ((ui::EF_LEFT_BUTTON_DOWN |
+    ui::EF_RIGHT_BUTTON_DOWN) & e.flags()) != 0;
 }
 
 void ButtonDropDown::ShowDropDownMenu(gfx::NativeView window) {
diff --git a/views/controls/button/custom_button.cc b/views/controls/button/custom_button.cc
index 56abaeb..cf2f752 100644
--- a/views/controls/button/custom_button.cc
+++ b/views/controls/button/custom_button.cc
@@ -118,14 +118,14 @@ CustomButton::CustomButton(ButtonListener* listener)
       state_(BS_NORMAL),
       animate_on_state_change_(true),
       is_throbbing_(false),
-      triggerable_event_flags_(MouseEvent::EF_LEFT_BUTTON_DOWN),
+      triggerable_event_flags_(ui::EF_LEFT_BUTTON_DOWN),
       request_focus_on_press_(true) {
   hover_animation_.reset(new ui::ThrobAnimation(this));
   hover_animation_->SetSlideDuration(kHoverFadeDurationMs);
 }
 
 bool CustomButton::IsTriggerableEvent(const MouseEvent& e) {
-  return (triggerable_event_flags_ & e.GetFlags()) != 0;
+  return (triggerable_event_flags_ & e.flags()) != 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -136,7 +136,7 @@ bool CustomButton::AcceleratorPressed(const Accelerator& accelerator) {
     return false;
 
   SetState(BS_NORMAL);
-  KeyEvent key_event(Event::ET_KEY_RELEASED, accelerator.GetKeyCode(),
+  KeyEvent key_event(ui::ET_KEY_RELEASED, accelerator.GetKeyCode(),
                      accelerator.modifiers(), 0, 0);
   NotifyClick(key_event);
   return true;
@@ -203,9 +203,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() == ui::VKEY_SPACE) {
+  if (e.key_code() == ui::VKEY_SPACE) {
     SetState(BS_PUSHED);
-  } else if (e.GetKeyCode() == ui::VKEY_RETURN) {
+  } else if (e.key_code() == ui::VKEY_RETURN) {
     SetState(BS_NORMAL);
     NotifyClick(e);
   } else {
@@ -215,7 +215,7 @@ bool CustomButton::OnKeyPressed(const KeyEvent& e) {
 }
 
 bool CustomButton::OnKeyReleased(const KeyEvent& e) {
-  if ((state_ == BS_DISABLED) || (e.GetKeyCode() != ui::VKEY_SPACE))
+  if ((state_ == BS_DISABLED) || (e.key_code() != ui::VKEY_SPACE))
     return false;
 
   SetState(BS_NORMAL);
diff --git a/views/controls/button/menu_button.cc b/views/controls/button/menu_button.cc
index 0cd933e..766b3dc 100644
--- a/views/controls/button/menu_button.cc
+++ b/views/controls/button/menu_button.cc
@@ -220,14 +220,18 @@ void MenuButton::OnMouseReleased(const MouseEvent& e,
 }
 
 bool MenuButton::OnKeyPressed(const KeyEvent& e) {
-  if (e.GetKeyCode() == ui::VKEY_SPACE ||
-      e.GetKeyCode() == ui::VKEY_RETURN ||
-      e.GetKeyCode() == ui::VKEY_UP ||
-      e.GetKeyCode() == ui::VKEY_DOWN) {
-    bool result = Activate();
-    if (GetFocusManager()->GetFocusedView() == NULL)
-      RequestFocus();
-    return result;
+  switch (e.key_code()) {
+    case ui::VKEY_SPACE:
+    case ui::VKEY_RETURN:
+    case ui::VKEY_UP:
+    case ui::VKEY_DOWN: {
+      bool result = Activate();
+      if (GetFocusManager()->GetFocusedView() == NULL)
+        RequestFocus();
+      return result;
+    }
+    default:
+      break;
   }
   return false;
 }
diff --git a/views/controls/button/native_button.cc b/views/controls/button/native_button.cc
index 65f6e0b..b822f51 100644
--- a/views/controls/button/native_button.cc
+++ b/views/controls/button/native_button.cc
@@ -116,9 +116,9 @@ void NativeButton::ButtonPressed() {
   gfx::Point cursor_point = Screen::GetCursorScreenPoint();
 #endif
 
-  views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
+  views::MouseEvent event(ui::ET_MOUSE_RELEASED,
                           cursor_point.x(), cursor_point.y(),
-                          views::Event::EF_LEFT_BUTTON_DOWN);
+                          ui::EF_LEFT_BUTTON_DOWN);
   NotifyClick(event);
 }
 
@@ -192,9 +192,9 @@ bool NativeButton::AcceleratorPressed(const Accelerator& accelerator) {
 #elif defined(OS_LINUX)
     gfx::Point cursor_point = Screen::GetCursorScreenPoint();
 #endif
-    views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
+    views::MouseEvent event(ui::ET_MOUSE_RELEASED,
                             cursor_point.x(), cursor_point.y(),
-                            views::Event::EF_LEFT_BUTTON_DOWN);
+                            ui::EF_LEFT_BUTTON_DOWN);
     NotifyClick(event);
     return true;
   }
diff --git a/views/controls/combobox/combobox.cc b/views/controls/combobox/combobox.cc
index 0c7f293..2349bbb 100644
--- a/views/controls/combobox/combobox.cc
+++ b/views/controls/combobox/combobox.cc
@@ -77,7 +77,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() != ui::VKEY_ESCAPE ||
+  if (e.key_code() != ui::VKEY_ESCAPE ||
       e.IsShiftDown() || e.IsControlDown() || e.IsAltDown()) {
     return false;
   }
diff --git a/views/controls/link.cc b/views/controls/link.cc
index ab48bc2..de7512b 100644
--- a/views/controls/link.cc
+++ b/views/controls/link.cc
@@ -121,13 +121,13 @@ void Link::OnMouseReleased(const MouseEvent& e, bool canceled) {
     RequestFocus();
 
     if (controller_)
-      controller_->LinkActivated(this, e.GetFlags());
+      controller_->LinkActivated(this, e.flags());
   }
 }
 
 bool Link::OnKeyPressed(const KeyEvent& e) {
-  bool activate = ((e.GetKeyCode() == ui::VKEY_SPACE) ||
-                   (e.GetKeyCode() == ui::VKEY_RETURN));
+  bool activate = ((e.key_code() == ui::VKEY_SPACE) ||
+                   (e.key_code() == ui::VKEY_RETURN));
   if (!activate)
     return false;
 
@@ -137,15 +137,15 @@ bool Link::OnKeyPressed(const KeyEvent& e) {
   RequestFocus();
 
   if (controller_)
-    controller_->LinkActivated(this, e.GetFlags());
+    controller_->LinkActivated(this, e.flags());
 
   return true;
 }
 
 bool Link::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
   // Make sure we don't process space or enter as accelerators.
-  return (e.GetKeyCode() == ui::VKEY_SPACE) ||
-      (e.GetKeyCode() == ui::VKEY_RETURN);
+  return (e.key_code() == ui::VKEY_SPACE) ||
+      (e.key_code() == ui::VKEY_RETURN);
 }
 
 AccessibilityTypes::Role Link::GetAccessibleRole() {
@@ -165,7 +165,7 @@ void Link::SetEnabled(bool f) {
   }
 }
 
-gfx::NativeCursor Link::GetCursorForPoint(Event::EventType event_type,
+gfx::NativeCursor Link::GetCursorForPoint(ui::EventType event_type,
                                           const gfx::Point& p) {
   if (!enabled_)
     return NULL;
diff --git a/views/controls/link.h b/views/controls/link.h
index ab0c5c3..4c9cb8f 100644
--- a/views/controls/link.h
+++ b/views/controls/link.h
@@ -60,7 +60,7 @@ class Link : public Label {
   // Set whether the link is enabled.
   virtual void SetEnabled(bool f);
 
-  virtual gfx::NativeCursor GetCursorForPoint(Event::EventType event_type,
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
                                               const gfx::Point& p);
 
   virtual std::string GetClassName() const;
diff --git a/views/controls/menu/menu_controller.cc b/views/controls/menu/menu_controller.cc
index 660f8ef..ee41789 100644
--- a/views/controls/menu/menu_controller.cc
+++ b/views/controls/menu/menu_controller.cc
@@ -523,13 +523,13 @@ void MenuController::OnMouseReleased(SubmenuView* source,
   // contents of the folder.
   if (!part.is_scroll() && part.menu &&
       !(part.menu->HasSubmenu() &&
-        (event.GetFlags() == MouseEvent::EF_LEFT_BUTTON_DOWN))) {
+        (event.flags() == ui::EF_LEFT_BUTTON_DOWN))) {
     if (active_mouse_view_) {
       SendMouseReleaseToActiveView(source, event, false);
       return;
     }
     if (part.menu->GetDelegate()->IsTriggerableEvent(event)) {
-      Accept(part.menu, event.GetFlags());
+      Accept(part.menu, event.flags());
       return;
     }
   } else if (part.type == MenuPart::MENU_ITEM) {
@@ -1780,7 +1780,7 @@ void MenuController::UpdateActiveMouseView(SubmenuView* event_source,
   if (target != active_mouse_view_) {
     if (active_mouse_view_) {
       // Send a mouse release with cancel set to true.
-      MouseEvent release_event(Event::ET_MOUSE_RELEASED, -1, -1, 0);
+      MouseEvent release_event(ui::ET_MOUSE_RELEASED, -1, -1, 0);
       active_mouse_view_->OnMouseReleased(release_event, true);
 
       active_mouse_view_ = NULL;
@@ -1789,13 +1789,13 @@ void MenuController::UpdateActiveMouseView(SubmenuView* event_source,
     if (active_mouse_view_) {
       gfx::Point target_point(target_menu_loc);
       View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
-      MouseEvent mouse_entered_event(MouseEvent::ET_MOUSE_ENTERED,
+      MouseEvent mouse_entered_event(ui::ET_MOUSE_ENTERED,
                                      target_point.x(), target_point.y(), 0);
       active_mouse_view_->OnMouseEntered(mouse_entered_event);
 
-      MouseEvent mouse_pressed_event(MouseEvent::ET_MOUSE_PRESSED,
+      MouseEvent mouse_pressed_event(ui::ET_MOUSE_PRESSED,
                                      target_point.x(), target_point.y(),
-                                     event.GetFlags());
+                                     event.flags());
       active_mouse_view_->OnMousePressed(mouse_pressed_event);
     }
   }
@@ -1803,9 +1803,9 @@ void MenuController::UpdateActiveMouseView(SubmenuView* event_source,
   if (active_mouse_view_) {
     gfx::Point target_point(target_menu_loc);
     View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
-    MouseEvent mouse_dragged_event(MouseEvent::ET_MOUSE_DRAGGED,
+    MouseEvent mouse_dragged_event(ui::ET_MOUSE_DRAGGED,
                                    target_point.x(), target_point.y(),
-                                   event.GetFlags());
+                                   event.flags());
     active_mouse_view_->OnMouseDragged(mouse_dragged_event);
   }
 }
@@ -1820,8 +1820,8 @@ void MenuController::SendMouseReleaseToActiveView(SubmenuView* event_source,
   View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                              &target_loc);
   View::ConvertPointToView(NULL, active_mouse_view_, &target_loc);
-  MouseEvent release_event(Event::ET_MOUSE_RELEASED, target_loc.x(),
-                           target_loc.y(), event.GetFlags());
+  MouseEvent release_event(ui::ET_MOUSE_RELEASED, target_loc.x(),
+                           target_loc.y(), event.flags());
   // Reset the active_mouse_view_ before sending mouse released. That way if if
   // calls back to use we aren't in a weird state.
   View* active_view = active_mouse_view_;
@@ -1833,7 +1833,7 @@ void MenuController::SendMouseReleaseToActiveView() {
   if (!active_mouse_view_)
     return;
 
-  MouseEvent release_event(Event::ET_MOUSE_RELEASED, -1, -1, 0);
+  MouseEvent release_event(ui::ET_MOUSE_RELEASED, -1, -1, 0);
   // Reset the active_mouse_view_ before sending mouse released. That way if if
   // calls back to use we aren't in a weird state.
   View* active_view = active_mouse_view_;
diff --git a/views/controls/menu/submenu_view.cc b/views/controls/menu/submenu_view.cc
index 56bd103..8a1f079 100644
--- a/views/controls/menu/submenu_view.cc
+++ b/views/controls/menu/submenu_view.cc
@@ -195,11 +195,11 @@ bool SubmenuView::OnMouseWheel(const MouseWheelEvent& e) {
   // If the first item isn't entirely visible, make it visible, otherwise make
   // the next/previous one entirely visible.
 #if defined(OS_WIN)
-  int delta = abs(e.GetOffset() / WHEEL_DELTA);
+  int delta = abs(e.offset() / WHEEL_DELTA);
 #elif defined(OS_LINUX)
-  int delta = abs(e.GetOffset());
+  int delta = abs(e.offset());
 #endif
-  for (bool scroll_up = (e.GetOffset() > 0); delta != 0; --delta) {
+  for (bool scroll_up = (e.offset() > 0); delta != 0; --delta) {
     int scroll_target;
     if (scroll_up) {
       if (GetMenuItemAt(first_vis_index)->y() == vis_bounds.y()) {
diff --git a/views/controls/resize_area.cc b/views/controls/resize_area.cc
index 3a0fd65..b3897bb 100644
--- a/views/controls/resize_area.cc
+++ b/views/controls/resize_area.cc
@@ -34,7 +34,7 @@ std::string ResizeArea::GetClassName() const {
   return kViewClassName;
 }
 
-gfx::NativeCursor ResizeArea::GetCursorForPoint(Event::EventType event_type,
+gfx::NativeCursor ResizeArea::GetCursorForPoint(ui::EventType event_type,
                                                 const gfx::Point& p) {
   if (!enabled_)
     return NULL;
diff --git a/views/controls/resize_area.h b/views/controls/resize_area.h
index 4f398ca..9adb60c 100644
--- a/views/controls/resize_area.h
+++ b/views/controls/resize_area.h
@@ -42,7 +42,7 @@ class ResizeArea : public View {
 
   // Overridden from views::View:
   virtual std::string GetClassName() const;
-  virtual gfx::NativeCursor GetCursorForPoint(Event::EventType event_type,
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
                                               const gfx::Point& p);
   virtual bool OnMousePressed(const views::MouseEvent& event);
   virtual bool OnMouseDragged(const views::MouseEvent& event);
diff --git a/views/controls/scrollbar/bitmap_scroll_bar.cc b/views/controls/scrollbar/bitmap_scroll_bar.cc
index cf0e919..262545e 100644
--- a/views/controls/scrollbar/bitmap_scroll_bar.cc
+++ b/views/controls/scrollbar/bitmap_scroll_bar.cc
@@ -74,9 +74,9 @@ class AutorepeatButton : public ImageButton {
 #elif defined(OS_LINUX)
     gfx::Point cursor_point = Screen::GetCursorScreenPoint();
 #endif
-    views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
+    views::MouseEvent event(ui::ET_MOUSE_RELEASED,
                             cursor_point.x(), cursor_point.y(),
-                            views::Event::EF_LEFT_BUTTON_DOWN);
+                            ui::EF_LEFT_BUTTON_DOWN);
     Button::NotifyClick(event);
   }
 
@@ -491,13 +491,13 @@ void BitmapScrollBar::OnMouseReleased(const MouseEvent& event, bool canceled) {
 }
 
 bool BitmapScrollBar::OnMouseWheel(const MouseWheelEvent& event) {
-  ScrollByContentsOffset(event.GetOffset());
+  ScrollByContentsOffset(event.offset());
   return true;
 }
 
 bool BitmapScrollBar::OnKeyPressed(const KeyEvent& event) {
   ScrollAmount amount = SCROLL_NONE;
-  switch (event.GetKeyCode()) {
+  switch (event.key_code()) {
     case ui::VKEY_UP:
       if (!IsHorizontal())
         amount = SCROLL_PREV_LINE;
diff --git a/views/controls/scrollbar/native_scroll_bar_gtk.cc b/views/controls/scrollbar/native_scroll_bar_gtk.cc
index 73bb109..dc1a9b6 100644
--- a/views/controls/scrollbar/native_scroll_bar_gtk.cc
+++ b/views/controls/scrollbar/native_scroll_bar_gtk.cc
@@ -44,7 +44,7 @@ gfx::Size NativeScrollBarGtk::GetPreferredSize() {
 bool NativeScrollBarGtk::OnKeyPressed(const KeyEvent& event) {
   if (!native_view())
     return false;
-  switch (event.GetKeyCode()) {
+  switch (event.key_code()) {
     case ui::VKEY_UP:
       if (!native_scroll_bar_->IsHorizontal())
         MoveStep(false /* negative */);
@@ -82,7 +82,7 @@ bool NativeScrollBarGtk::OnKeyPressed(const KeyEvent& event) {
 bool NativeScrollBarGtk::OnMouseWheel(const MouseWheelEvent& e) {
   if (!native_view())
     return false;
-  MoveBy(-e.GetOffset());  // e.GetOffset() > 0 means scroll up.
+  MoveBy(-e.offset());  // e.GetOffset() > 0 means scroll up.
   return true;
 }
 
diff --git a/views/controls/scrollbar/native_scroll_bar_win.cc b/views/controls/scrollbar/native_scroll_bar_win.cc
index 44d8bf6..01cd5f8 100644
--- a/views/controls/scrollbar/native_scroll_bar_win.cc
+++ b/views/controls/scrollbar/native_scroll_bar_win.cc
@@ -230,7 +230,7 @@ bool NativeScrollBarWin::OnKeyPressed(const KeyEvent& event) {
   if (!sb_container_.get())
     return false;
   int code = -1;
-  switch (event.GetKeyCode()) {
+  switch (event.key_code()) {
     case ui::VKEY_UP:
       if (!native_scroll_bar_->IsHorizontal())
         code = SB_LINEUP;
@@ -272,7 +272,7 @@ bool NativeScrollBarWin::OnKeyPressed(const KeyEvent& event) {
 bool NativeScrollBarWin::OnMouseWheel(const MouseWheelEvent& e) {
   if (!sb_container_.get())
     return false;
-  sb_container_->ScrollWithOffset(e.GetOffset());
+  sb_container_->ScrollWithOffset(e.offset());
   return true;
 }
 
diff --git a/views/controls/single_split_view.cc b/views/controls/single_split_view.cc
index ad2a59a..2b076d6 100644
--- a/views/controls/single_split_view.cc
+++ b/views/controls/single_split_view.cc
@@ -91,7 +91,7 @@ gfx::Size SingleSplitView::GetPreferredSize() {
 }
 
 gfx::NativeCursor SingleSplitView::GetCursorForPoint(
-    Event::EventType event_type,
+    ui::EventType event_type,
     const gfx::Point& p) {
   if (IsPointInDivider(p)) {
 #if defined(OS_WIN)
diff --git a/views/controls/single_split_view.h b/views/controls/single_split_view.h
index 57f4cc3..dc69c67 100644
--- a/views/controls/single_split_view.h
+++ b/views/controls/single_split_view.h
@@ -49,7 +49,7 @@ class SingleSplitView : public views::View {
   virtual gfx::Size GetPreferredSize();
 
   // Overriden to return a resize cursor when over the divider.
-  virtual gfx::NativeCursor GetCursorForPoint(Event::EventType event_type,
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
                                               const gfx::Point& p);
 
   Orientation orientation() const {
diff --git a/views/controls/single_split_view_unittest.cc b/views/controls/single_split_view_unittest.cc
index a42e3b8..65fbb00 100644
--- a/views/controls/single_split_view_unittest.cc
+++ b/views/controls/single_split_view_unittest.cc
@@ -146,25 +146,25 @@ TEST(SingleSplitViewTest, MouseDrag) {
 
   // Drag divider to the right, in 2 steps.
   MouseEvent mouse_pressed(
-      Event::ET_MOUSE_PRESSED, 7, kInitialDividerOffset + kMouseOffset, 0);
+      ui::ET_MOUSE_PRESSED, 7, kInitialDividerOffset + kMouseOffset, 0);
   ASSERT_TRUE(split.OnMousePressed(mouse_pressed));
   EXPECT_EQ(kInitialDividerOffset, split.divider_offset());
 
   MouseEvent mouse_dragged_1(
-      Event::ET_MOUSE_DRAGGED, 5,
+      ui::ET_MOUSE_DRAGGED, 5,
       kInitialDividerOffset + kMouseOffset + kMouseMoveDelta, 0);
   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_1));
   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta, split.divider_offset());
 
   MouseEvent mouse_dragged_2(
-      Event::ET_MOUSE_DRAGGED, 6,
+      ui::ET_MOUSE_DRAGGED, 6,
       kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2, 0);
   ASSERT_TRUE(split.OnMouseDragged(mouse_dragged_2));
   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
             split.divider_offset());
 
   MouseEvent mouse_released(
-      Event::ET_MOUSE_RELEASED, 7,
+      ui::ET_MOUSE_RELEASED, 7,
       kInitialDividerOffset + kMouseOffset + kMouseMoveDelta * 2, 0);
   split.OnMouseReleased(mouse_released, false);
   EXPECT_EQ(kInitialDividerOffset + kMouseMoveDelta * 2,
diff --git a/views/controls/textfield/native_textfield_views.cc b/views/controls/textfield/native_textfield_views.cc
index 11649ebf..529fed1 100644
--- a/views/controls/textfield/native_textfield_views.cc
+++ b/views/controls/textfield/native_textfield_views.cc
@@ -139,7 +139,7 @@ void NativeTextfieldViews::WillLoseFocus() {
 }
 
 gfx::NativeCursor NativeTextfieldViews::GetCursorForPoint(
-    Event::EventType event_type,
+    ui::EventType event_type,
     const gfx::Point& p) {
 #if defined(OS_WIN)
   static HCURSOR ibeam = LoadCursor(NULL, IDC_IBEAM);
@@ -531,8 +531,8 @@ void NativeTextfieldViews::PaintTextAndCursor(gfx::Canvas* canvas) {
 
 bool NativeTextfieldViews::HandleKeyEvent(const KeyEvent& key_event) {
   // TODO(oshima): handle IME.
-  if (key_event.GetType() == views::Event::ET_KEY_PRESSED) {
-    ui::KeyboardCode key_code = key_event.GetKeyCode();
+  if (key_event.type() == ui::ET_KEY_PRESSED) {
+    ui::KeyboardCode key_code = key_event.key_code();
     // TODO(oshima): shift-tab does not work. Figure out why and fix.
     if (key_code == ui::VKEY_TAB)
       return false;
@@ -642,7 +642,7 @@ bool NativeTextfieldViews::HandleKeyEvent(const KeyEvent& key_event) {
 char16 NativeTextfieldViews::GetPrintableChar(const KeyEvent& key_event) {
   // TODO(oshima): IME, i18n support.
   // This only works for UCS-2 characters.
-  ui::KeyboardCode key_code = key_event.GetKeyCode();
+  ui::KeyboardCode key_code = key_event.key_code();
   bool shift = key_event.IsShiftDown();
   bool upper = shift ^ key_event.IsCapsLockDown();
   // TODO(oshima): We should have a utility function
@@ -790,9 +790,9 @@ size_t NativeTextfieldViews::FindCursorPosition(const gfx::Point& point) const {
 
 bool NativeTextfieldViews::HandleMousePressed(const views::MouseEvent& e) {
   textfield_->RequestFocus();
-  base::TimeDelta time_delta = e.GetTimeStamp() - last_mouse_press_time_;
+  base::TimeDelta time_delta = e.time_stamp() - last_mouse_press_time_;
   gfx::Point location_delta = e.location().Subtract(last_mouse_press_location_);
-  last_mouse_press_time_ = e.GetTimeStamp();
+  last_mouse_press_time_ = e.time_stamp();
   last_mouse_press_location_ = e.location();
   if (e.IsLeftMouseButton()) {
     if (!ExceededDragThreshold(location_delta.x(), location_delta.y())
diff --git a/views/controls/textfield/native_textfield_views.h b/views/controls/textfield/native_textfield_views.h
index 4bf2be0..3a961fd 100644
--- a/views/controls/textfield/native_textfield_views.h
+++ b/views/controls/textfield/native_textfield_views.h
@@ -57,7 +57,7 @@ class NativeTextfieldViews : public views::View,
   virtual void WillGainFocus();
   virtual void DidGainFocus();
   virtual void WillLoseFocus();
-  virtual gfx::NativeCursor GetCursorForPoint(Event::EventType event_type,
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
                                               const gfx::Point& p);
 
   // views::ContextMenuController overrides:
diff --git a/views/controls/textfield/native_textfield_views_unittest.cc b/views/controls/textfield/native_textfield_views_unittest.cc
index b593d1d..3c35e59 100644
--- a/views/controls/textfield/native_textfield_views_unittest.cc
+++ b/views/controls/textfield/native_textfield_views_unittest.cc
@@ -113,10 +113,10 @@ class NativeTextfieldViewsTest : public ViewsTestBase,
                                     bool shift,
                                     bool control,
                                     bool capslock) {
-    int flags = (shift ? KeyEvent::EF_SHIFT_DOWN : 0) |
-        (control ? KeyEvent::EF_CONTROL_DOWN : 0) |
-        (capslock ? KeyEvent::EF_CAPS_LOCK_DOWN : 0);
-    KeyEvent event(KeyEvent::ET_KEY_PRESSED, key_code, flags, 1, 0);
+    int flags = (shift ? ui::EF_SHIFT_DOWN : 0) |
+        (control ? ui::EF_CONTROL_DOWN : 0) |
+        (capslock ? ui::EF_CAPS_LOCK_DOWN : 0);
+    KeyEvent event(ui::ET_KEY_PRESSED, key_code, flags, 1, 0);
     return textfield_->OnKeyPressed(event);
   }
 
@@ -435,7 +435,7 @@ TEST_F(NativeTextfieldViewsTest, ContextMenuDisplayTest) {
 TEST_F(NativeTextfieldViewsTest, DoubleAndTripleClickTest) {
   InitTextfield(Textfield::STYLE_DEFAULT);
   textfield_->SetText(ASCIIToUTF16("hello world"));
-  MouseEvent me(MouseEvent::ET_MOUSE_PRESSED, 0, 0, Event::EF_LEFT_BUTTON_DOWN);
+  MouseEvent me(ui::ET_MOUSE_PRESSED, 0, 0, ui::EF_LEFT_BUTTON_DOWN);
   EXPECT_EQ(NativeTextfieldViews::NONE, GetClickState());
 
   // Test for double click.
diff --git a/views/controls/textfield/native_textfield_win.cc b/views/controls/textfield/native_textfield_win.cc
index 681b15f..c229eb90 100644
--- a/views/controls/textfield/native_textfield_win.cc
+++ b/views/controls/textfield/native_textfield_win.cc
@@ -940,22 +940,22 @@ void NativeTextfieldWin::HandleKeystroke(UINT message,
   Textfield::Controller* controller = textfield_->GetController();
   bool handled = false;
   if (controller) {
-    Event::EventType type;
+    ui::EventType type;
     switch (message) {
       case WM_KEYDOWN:
       case WM_SYSKEYDOWN:
       case WM_CHAR:
       case WM_SYSCHAR:
-        type = Event::ET_KEY_PRESSED;
+        type = ui::ET_KEY_PRESSED;
         break;
       case WM_KEYUP:
       case WM_SYSKEYUP:
-        type = Event::ET_KEY_RELEASED;
+        type = ui::ET_KEY_RELEASED;
         break;
       default:
         NOTREACHED() << "Unknown message:" << message;
         // Passing through to avoid crash on release build.
-        type = Event::ET_KEY_PRESSED;
+        type = ui::ET_KEY_PRESSED;
     }
     KeyEvent key_event(type,
                        ui::KeyboardCodeForWindowsKeyCode(key),
diff --git a/views/controls/textfield/textfield.cc b/views/controls/textfield/textfield.cc
index 1b4461c..9028f88 100644
--- a/views/controls/textfield/textfield.cc
+++ b/views/controls/textfield/textfield.cc
@@ -309,7 +309,7 @@ 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.
-  ui::KeyboardCode key = e.GetKeyCode();
+  ui::KeyboardCode key = e.key_code();
   if (key == ui::VKEY_BACK)
     return true;  // We'll handle BackSpace ourselves.
 
diff --git a/views/events/event.cc b/views/events/event.cc
index e5e0a5a..565165b 100644
--- a/views/events/event.cc
+++ b/views/events/event.cc
@@ -8,7 +8,7 @@
 
 namespace views {
 
-Event::Event(EventType type, int flags)
+Event::Event(ui::EventType type, int flags)
     : type_(type),
       time_stamp_(base::Time::NowFromSystemTime()),
       flags_(flags) {
@@ -21,7 +21,7 @@ LocatedEvent::LocatedEvent(const LocatedEvent& model, View* from, View* to)
     View::ConvertPointToView(from, to, &location_);
 }
 
-KeyEvent::KeyEvent(EventType type, ui::KeyboardCode key_code,
+KeyEvent::KeyEvent(ui::EventType type, ui::KeyboardCode key_code,
                    int event_flags, int repeat_count, int message_flags)
     : Event(type, event_flags),
       key_code_(key_code),
@@ -29,7 +29,7 @@ KeyEvent::KeyEvent(EventType type, ui::KeyboardCode key_code,
       message_flags_(message_flags) {
 }
 
-MouseEvent::MouseEvent(EventType type,
+MouseEvent::MouseEvent(ui::EventType type,
                        View* from,
                        View* to,
                        const gfx::Point &l,
@@ -44,13 +44,13 @@ MouseEvent::MouseEvent(const MouseEvent& model, View* from, View* to)
 }
 
 #if defined(TOUCH_UI)
-TouchEvent::TouchEvent(EventType type, int x, int y, int flags, int touch_id)
+TouchEvent::TouchEvent(ui::EventType type, int x, int y, int flags, int touch_id)
       : LocatedEvent(type, gfx::Point(x, y), flags),
         touch_id_(touch_id) {
 }
 
 
-TouchEvent::TouchEvent(EventType type,
+TouchEvent::TouchEvent(ui::EventType type,
                        View* from,
                        View* to,
                        const gfx::Point& l,
diff --git a/views/events/event.h b/views/events/event.h
index b16371e..385e49c 100644
--- a/views/events/event.h
+++ b/views/events/event.h
@@ -8,8 +8,10 @@
 
 #include "base/basictypes.h"
 #include "base/time.h"
+#include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
+#include "views/native_types.h"
 
 #if defined(OS_LINUX)
 typedef struct _GdkEventKey GdkEventKey;
@@ -42,95 +44,36 @@ class View;
 ////////////////////////////////////////////////////////////////////////////////
 class Event {
  public:
-  // Event types. (prefixed because of a conflict with windows headers)
-  enum EventType { ET_UNKNOWN = 0,
-                   ET_MOUSE_PRESSED,
-                   ET_MOUSE_DRAGGED,
-                   ET_MOUSE_RELEASED,
-                   ET_MOUSE_MOVED,
-                   ET_MOUSE_ENTERED,
-                   ET_MOUSE_EXITED,
-                   ET_KEY_PRESSED,
-                   ET_KEY_RELEASED,
-                   ET_MOUSEWHEEL,
-#if defined(TOUCH_UI)
-                   ET_TOUCH_RELEASED,
-                   ET_TOUCH_PRESSED,
-                   ET_TOUCH_MOVED,
-                   ET_TOUCH_STATIONARY,
-                   ET_TOUCH_CANCELLED,
-#endif
-                   ET_DROP_TARGET_EVENT };
-
-  // Event flags currently supported.  Although this is a "views"
-  // file, this header is used on non-views platforms (e.g. OSX).  For
-  // example, these EventFlags are used by the automation provider for
-  // all platforms.
-  enum EventFlags { EF_CAPS_LOCK_DOWN     = 1 << 0,
-                    EF_SHIFT_DOWN         = 1 << 1,
-                    EF_CONTROL_DOWN       = 1 << 2,
-                    EF_ALT_DOWN           = 1 << 3,
-                    EF_LEFT_BUTTON_DOWN   = 1 << 4,
-                    EF_MIDDLE_BUTTON_DOWN = 1 << 5,
-                    EF_RIGHT_BUTTON_DOWN  = 1 << 6,
-                    EF_COMMAND_DOWN       = 1 << 7,  // Only useful on OSX
-  };
-
-  // Return the event type
-  EventType GetType() const {
-    return type_;
-  }
-
-  // Return the event time stamp.
-  const base::Time& GetTimeStamp() const {
-    return time_stamp_;
-  }
-
-  // Return the flags
-  int GetFlags() const {
-    return flags_;
-  }
-
-  void set_flags(int flags) {
-    flags_ = flags;
-  }
-
-  // Return whether the shift modifier is down
-  bool IsShiftDown() const {
-    return (flags_ & EF_SHIFT_DOWN) != 0;
-  }
-
-  // Return whether the control modifier is down
-  bool IsControlDown() const {
-    return (flags_ & EF_CONTROL_DOWN) != 0;
-  }
-
-  bool IsCapsLockDown() const {
-    return (flags_ & EF_CAPS_LOCK_DOWN) != 0;
-  }
-
-  // Return whether the alt modifier is down
-  bool IsAltDown() const {
-    return (flags_ & EF_ALT_DOWN) != 0;
-  }
+  const NativeEvent& native_event() const { return native_event_; }
+  ui::EventType type() const { return type_; }
+  const base::Time& time_stamp() const { return time_stamp_; }
+  int flags() const { return flags_; }
+  void set_flags(int flags) { flags_ = flags; }
+
+  // The following methods return true if the respective keys were pressed at
+  // the time the event was created.
+  bool IsShiftDown() const { return (flags_ & ui::EF_SHIFT_DOWN) != 0; }
+  bool IsControlDown() const { return (flags_ & ui::EF_CONTROL_DOWN) != 0; }
+  bool IsCapsLockDown() const { return (flags_ & ui::EF_CAPS_LOCK_DOWN) != 0; }
+  bool IsAltDown() const { return (flags_ & ui::EF_ALT_DOWN) != 0; }
 
   bool IsMouseEvent() const {
-    return type_ == ET_MOUSE_PRESSED ||
-           type_ == ET_MOUSE_DRAGGED ||
-           type_ == ET_MOUSE_RELEASED ||
-           type_ == ET_MOUSE_MOVED ||
-           type_ == ET_MOUSE_ENTERED ||
-           type_ == ET_MOUSE_EXITED ||
-           type_ == ET_MOUSEWHEEL;
+    return type_ == ui::ET_MOUSE_PRESSED ||
+           type_ == ui::ET_MOUSE_DRAGGED ||
+           type_ == ui::ET_MOUSE_RELEASED ||
+           type_ == ui::ET_MOUSE_MOVED ||
+           type_ == ui::ET_MOUSE_ENTERED ||
+           type_ == ui::ET_MOUSE_EXITED ||
+           type_ == ui::ET_MOUSEWHEEL;
   }
 
 #if defined(TOUCH_UI)
   bool IsTouchEvent() const {
-    return type_ == ET_TOUCH_RELEASED ||
-           type_ == ET_TOUCH_PRESSED ||
-           type_ == ET_TOUCH_MOVED ||
-           type_ == ET_TOUCH_STATIONARY ||
-           type_ == ET_TOUCH_CANCELLED;
+    return type_ == ui::ET_TOUCH_RELEASED ||
+           type_ == ui::ET_TOUCH_PRESSED ||
+           type_ == ui::ET_TOUCH_MOVED ||
+           type_ == ui::ET_TOUCH_STATIONARY ||
+           type_ == ui::ET_TOUCH_CANCELLED;
   }
 #endif
 
@@ -146,18 +89,20 @@ class Event {
 #endif
 
  protected:
-  Event(EventType type, int flags);
+  Event(ui::EventType type, int flags);
 
   Event(const Event& model)
-      : type_(model.GetType()),
-        time_stamp_(model.GetTimeStamp()),
-        flags_(model.GetFlags()) {
+      : native_event_(model.native_event()),
+        type_(model.type()),
+        time_stamp_(model.time_stamp()),
+        flags_(model.flags()) {
   }
 
  private:
   void operator=(const Event&);
 
-  EventType type_;
+  NativeEvent native_event_;
+  ui::EventType type_;
   base::Time time_stamp_;
   int flags_;
 };
@@ -172,7 +117,7 @@ class Event {
 ////////////////////////////////////////////////////////////////////////////////
 class LocatedEvent : public Event {
  public:
-  LocatedEvent(EventType type, const gfx::Point& location, int flags)
+  LocatedEvent(ui::EventType type, const gfx::Point& location, int flags)
       : Event(type, flags),
         location_(location) {
   }
@@ -182,20 +127,9 @@ class LocatedEvent : public Event {
   // from 'from' coordinate system to 'to' coordinate system
   LocatedEvent(const LocatedEvent& model, View* from, View* to);
 
-  // Returns the X location.
-  int x() const {
-    return location_.x();
-  }
-
-  // Returns the Y location.
-  int y() const {
-    return location_.y();
-  }
-
-  // Returns the location.
-  const gfx::Point& location() const {
-    return location_;
-  }
+  int x() const { return location_.x(); }
+  int y() const { return location_.y(); }
+  const gfx::Point& location() const { return location_; }
 
  private:
   gfx::Point location_;
@@ -210,21 +144,15 @@ class LocatedEvent : public Event {
 ////////////////////////////////////////////////////////////////////////////////
 class MouseEvent : public LocatedEvent {
  public:
-  // Flags specific to mouse events
-  enum MouseEventFlags {
-    EF_IS_DOUBLE_CLICK = 1 << 16,
-    EF_IS_NON_CLIENT = 1 << 17
-  };
-
   // Create a new mouse event
-  MouseEvent(EventType type, int x, int y, int flags)
+  MouseEvent(ui::EventType type, int x, int y, int flags)
       : LocatedEvent(type, gfx::Point(x, y), flags) {
   }
 
   // Create a new mouse event from a type and a point. If from / to views
   // are provided, the point will be converted from 'from' coordinate system to
   // 'to' coordinate system.
-  MouseEvent(EventType type,
+  MouseEvent(ui::EventType type,
              View* from,
              View* to,
              const gfx::Point &l,
@@ -242,30 +170,30 @@ class MouseEvent : public LocatedEvent {
 
   // Conveniences to quickly test what button is down
   bool IsOnlyLeftMouseButton() const {
-    return (GetFlags() & EF_LEFT_BUTTON_DOWN) &&
-      !(GetFlags() & (EF_MIDDLE_BUTTON_DOWN | EF_RIGHT_BUTTON_DOWN));
+    return (flags() & ui::EF_LEFT_BUTTON_DOWN) &&
+      !(flags() & (ui::EF_MIDDLE_BUTTON_DOWN | ui::EF_RIGHT_BUTTON_DOWN));
   }
 
   bool IsLeftMouseButton() const {
-    return (GetFlags() & EF_LEFT_BUTTON_DOWN) != 0;
+    return (flags() & ui::EF_LEFT_BUTTON_DOWN) != 0;
   }
 
   bool IsOnlyMiddleMouseButton() const {
-    return (GetFlags() & EF_MIDDLE_BUTTON_DOWN) &&
-      !(GetFlags() & (EF_LEFT_BUTTON_DOWN | EF_RIGHT_BUTTON_DOWN));
+    return (flags() & ui::EF_MIDDLE_BUTTON_DOWN) &&
+      !(flags() & (ui::EF_LEFT_BUTTON_DOWN | ui::EF_RIGHT_BUTTON_DOWN));
   }
 
   bool IsMiddleMouseButton() const {
-    return (GetFlags() & EF_MIDDLE_BUTTON_DOWN) != 0;
+    return (flags() & ui::EF_MIDDLE_BUTTON_DOWN) != 0;
   }
 
   bool IsOnlyRightMouseButton() const {
-    return (GetFlags() & EF_RIGHT_BUTTON_DOWN) &&
-      !(GetFlags() & (EF_LEFT_BUTTON_DOWN | EF_MIDDLE_BUTTON_DOWN));
+    return (flags() & ui::EF_RIGHT_BUTTON_DOWN) &&
+      !(flags() & (ui::EF_LEFT_BUTTON_DOWN | ui::EF_MIDDLE_BUTTON_DOWN));
   }
 
   bool IsRightMouseButton() const {
-    return (GetFlags() & EF_RIGHT_BUTTON_DOWN) != 0;
+    return (flags() & ui::EF_RIGHT_BUTTON_DOWN) != 0;
   }
 
  private:
@@ -285,12 +213,12 @@ class MouseEvent : public LocatedEvent {
 class TouchEvent : public LocatedEvent {
  public:
   // Create a new touch event.
-  TouchEvent(EventType type, int x, int y, int flags, int touch_id);
+  TouchEvent(ui::EventType type, int x, int y, int flags, int touch_id);
 
   // Create a new touch event from a type and a point. If from / to views
   // are provided, the point will be converted from 'from' coordinate system to
   // 'to' coordinate system.
-  TouchEvent(EventType type,
+  TouchEvent(ui::EventType type,
              View* from,
              View* to,
              const gfx::Point& l,
@@ -306,10 +234,7 @@ class TouchEvent : public LocatedEvent {
   explicit TouchEvent(XEvent* xev);
 #endif
 
-  // Return the touch point for this event.
-  bool identity() const {
-    return touch_id_;
-  }
+  bool identity() const { return touch_id_; }
 
  private:
   // The identity (typically finger) of the touch starting at 0 and incrementing
@@ -331,14 +256,14 @@ class TouchEvent : public LocatedEvent {
 class KeyEvent : public Event {
  public:
   // Create a new key event
-  KeyEvent(EventType type,
+  KeyEvent(ui::EventType type,
            ui::KeyboardCode key_code,
            int event_flags,
            int repeat_count,
            int message_flags);
 
 #if defined(OS_WIN)
-  KeyEvent(EventType type,
+  KeyEvent(ui::EventType type,
            ui::KeyboardCode key_code,
            int event_flags,
            int repeat_count,
@@ -355,25 +280,15 @@ class KeyEvent : public Event {
   explicit KeyEvent(XEvent* xevent);
 #endif
 
-  // 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.
-  ui::KeyboardCode GetKeyCode() const {
-    return key_code_;
-  }
+  ui::KeyboardCode key_code() const { return key_code_; }
 
 #if defined(OS_WIN)
   bool IsExtendedKey() const;
 
-  UINT message() const {
-    return message_;
-  }
+  UINT message() const { return message_; }
 #endif
 
-  int GetRepeatCount() const {
-    return repeat_count_;
-  }
+  int repeat_count() const { return repeat_count_; }
 
 #if defined(OS_WIN)
   static int GetKeyStateFlags();
@@ -404,7 +319,7 @@ class MouseWheelEvent : public LocatedEvent {
  public:
   // Create a new key event
   MouseWheelEvent(int offset, int x, int y, int flags)
-      : LocatedEvent(ET_MOUSEWHEEL, gfx::Point(x, y), flags),
+      : LocatedEvent(ui::ET_MOUSEWHEEL, gfx::Point(x, y), flags),
         offset_(offset) {
   }
 
@@ -412,9 +327,7 @@ class MouseWheelEvent : public LocatedEvent {
   explicit MouseWheelEvent(XEvent* xev);
 #endif
 
-  int GetOffset() const {
-    return offset_;
-  }
+  int offset() const { return offset_; }
 
  private:
   int offset_;
@@ -436,19 +349,19 @@ class DropTargetEvent : public LocatedEvent {
                   int x,
                   int y,
                   int source_operations)
-      : LocatedEvent(ET_DROP_TARGET_EVENT, gfx::Point(x, y), 0),
+      : LocatedEvent(ui::ET_DROP_TARGET_EVENT, gfx::Point(x, y), 0),
         data_(data),
         source_operations_(source_operations) {
   }
 
-  // Data associated with the drag/drop session.
-  const OSExchangeData& GetData() const { return data_; }
-
-  // Bitmask of supported ui::DragDropTypes::DragOperation by the source.
-  int GetSourceOperations() const { return source_operations_; }
+  const OSExchangeData& data() const { return data_; }
+  int source_operations() const { return source_operations_; }
 
  private:
+  // Data associated with the drag/drop session.
   const OSExchangeData& data_;
+
+  // Bitmask of supported ui::DragDropTypes::DragOperation by the source.
   int source_operations_;
 
   DISALLOW_COPY_AND_ASSIGN(DropTargetEvent);
diff --git a/views/events/event_gtk.cc b/views/events/event_gtk.cc
index e06ee32..b74621a 100644
--- a/views/events/event_gtk.cc
+++ b/views/events/event_gtk.cc
@@ -12,7 +12,7 @@ namespace views {
 
 KeyEvent::KeyEvent(const GdkEventKey* event)
     : Event(event->type == GDK_KEY_PRESS ?
-            Event::ET_KEY_PRESSED : Event::ET_KEY_RELEASED,
+            ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
             GetFlagsFromGdkState(event->state)),
       // TODO(erg): All these values are iffy.
       key_code_(ui::WindowsKeyCodeForGdkKeyCode(event->keyval)),
@@ -28,19 +28,19 @@ KeyEvent::KeyEvent(const GdkEventKey* event)
 int Event::GetFlagsFromGdkState(int state) {
   int flags = 0;
   if (state & GDK_LOCK_MASK)
-    flags |= Event::EF_CAPS_LOCK_DOWN;
+    flags |= ui::EF_CAPS_LOCK_DOWN;
   if (state & GDK_CONTROL_MASK)
-    flags |= Event::EF_CONTROL_DOWN;
+    flags |= ui::EF_CONTROL_DOWN;
   if (state & GDK_SHIFT_MASK)
-    flags |= Event::EF_SHIFT_DOWN;
+    flags |= ui::EF_SHIFT_DOWN;
   if (state & GDK_MOD1_MASK)
-    flags |= Event::EF_ALT_DOWN;
+    flags |= ui::EF_ALT_DOWN;
   if (state & GDK_BUTTON1_MASK)
-    flags |= Event::EF_LEFT_BUTTON_DOWN;
+    flags |= ui::EF_LEFT_BUTTON_DOWN;
   if (state & GDK_BUTTON2_MASK)
-    flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+    flags |= ui::EF_MIDDLE_BUTTON_DOWN;
   if (state & GDK_BUTTON3_MASK)
-    flags |= Event::EF_RIGHT_BUTTON_DOWN;
+    flags |= ui::EF_RIGHT_BUTTON_DOWN;
   return flags;
 }
 
diff --git a/views/events/event_win.cc b/views/events/event_win.cc
index fd33f9f..654d4c2 100644
--- a/views/events/event_win.cc
+++ b/views/events/event_win.cc
@@ -8,7 +8,7 @@
 
 namespace views {
 
-KeyEvent::KeyEvent(EventType type, ui::KeyboardCode key_code,
+KeyEvent::KeyEvent(ui::EventType type, ui::KeyboardCode key_code,
                    int event_flags, int repeat_count, int message_flags,
                    UINT message)
     : Event(type, event_flags),
@@ -21,11 +21,11 @@ KeyEvent::KeyEvent(EventType type, ui::KeyboardCode key_code,
 int Event::GetWindowsFlags() const {
   // TODO: need support for x1/x2.
   int result = 0;
-  result |= (flags_ & EF_SHIFT_DOWN) ? MK_SHIFT : 0;
-  result |= (flags_ & EF_CONTROL_DOWN) ? MK_CONTROL : 0;
-  result |= (flags_ & EF_LEFT_BUTTON_DOWN) ? MK_LBUTTON : 0;
-  result |= (flags_ & EF_MIDDLE_BUTTON_DOWN) ? MK_MBUTTON : 0;
-  result |= (flags_ & EF_RIGHT_BUTTON_DOWN) ? MK_RBUTTON : 0;
+  result |= (flags_ & ui::EF_SHIFT_DOWN) ? MK_SHIFT : 0;
+  result |= (flags_ & ui::EF_CONTROL_DOWN) ? MK_CONTROL : 0;
+  result |= (flags_ & ui::EF_LEFT_BUTTON_DOWN) ? MK_LBUTTON : 0;
+  result |= (flags_ & ui::EF_MIDDLE_BUTTON_DOWN) ? MK_MBUTTON : 0;
+  result |= (flags_ & ui::EF_RIGHT_BUTTON_DOWN) ? MK_RBUTTON : 0;
   return result;
 }
 
@@ -33,17 +33,17 @@ int Event::GetWindowsFlags() const {
 int Event::ConvertWindowsFlags(UINT win_flags) {
   int r = 0;
   if (win_flags & MK_CONTROL)
-    r |= EF_CONTROL_DOWN;
+    r |= ui::EF_CONTROL_DOWN;
   if (win_flags & MK_SHIFT)
-    r |= EF_SHIFT_DOWN;
+    r |= ui::EF_SHIFT_DOWN;
   if (GetKeyState(VK_MENU) < 0)
-    r |= EF_ALT_DOWN;
+    r |= ui::EF_ALT_DOWN;
   if (win_flags & MK_LBUTTON)
-    r |= EF_LEFT_BUTTON_DOWN;
+    r |= ui::EF_LEFT_BUTTON_DOWN;
   if (win_flags & MK_MBUTTON)
-    r |= EF_MIDDLE_BUTTON_DOWN;
+    r |= ui::EF_MIDDLE_BUTTON_DOWN;
   if (win_flags & MK_RBUTTON)
-    r |= EF_RIGHT_BUTTON_DOWN;
+    r |= ui::EF_RIGHT_BUTTON_DOWN;
   return r;
 }
 
@@ -54,11 +54,11 @@ int KeyEvent::GetKeyStateFlags() {
   // states.
   int flags = 0;
   if (GetKeyState(VK_MENU) & 0x80)
-    flags |= Event::EF_ALT_DOWN;
+    flags |= ui::EF_ALT_DOWN;
   if (GetKeyState(VK_SHIFT) & 0x80)
-    flags |= Event::EF_SHIFT_DOWN;
+    flags |= ui::EF_SHIFT_DOWN;
   if (GetKeyState(VK_CONTROL) & 0x80)
-    flags |= Event::EF_CONTROL_DOWN;
+    flags |= ui::EF_CONTROL_DOWN;
   return flags;
 }
 
diff --git a/views/events/event_x.cc b/views/events/event_x.cc
index 9c51c72..cce5999 100644
--- a/views/events/event_x.cc
+++ b/views/events/event_x.cc
@@ -23,19 +23,19 @@ static int kWheelScrollAmount = 53;
 int GetEventFlagsFromXState(unsigned int state) {
   int flags = 0;
   if (state & ControlMask)
-    flags |= Event::EF_CONTROL_DOWN;
+    flags |= ui::EF_CONTROL_DOWN;
   if (state & ShiftMask)
-    flags |= Event::EF_SHIFT_DOWN;
+    flags |= ui::EF_SHIFT_DOWN;
   if (state & Mod1Mask)
-    flags |= Event::EF_ALT_DOWN;
+    flags |= ui::EF_ALT_DOWN;
   if (state & LockMask)
-    flags |= Event::EF_CAPS_LOCK_DOWN;
+    flags |= ui::EF_CAPS_LOCK_DOWN;
   if (state & Button1Mask)
-    flags |= Event::EF_LEFT_BUTTON_DOWN;
+    flags |= ui::EF_LEFT_BUTTON_DOWN;
   if (state & Button2Mask)
-    flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+    flags |= ui::EF_MIDDLE_BUTTON_DOWN;
   if (state & Button3Mask)
-    flags |= Event::EF_RIGHT_BUTTON_DOWN;
+    flags |= ui::EF_RIGHT_BUTTON_DOWN;
 
   return flags;
 }
@@ -51,11 +51,11 @@ int GetEventFlagsFromXState(unsigned int state) {
 int GetEventFlagsForButton(int button) {
   switch (button) {
     case 1:
-      return Event::EF_LEFT_BUTTON_DOWN;
+      return ui::EF_LEFT_BUTTON_DOWN;
     case 2:
-      return Event::EF_MIDDLE_BUTTON_DOWN;
+      return ui::EF_MIDDLE_BUTTON_DOWN;
     case 3:
-      return Event::EF_RIGHT_BUTTON_DOWN;
+      return ui::EF_RIGHT_BUTTON_DOWN;
   }
 
   DLOG(WARNING) << "Unexpected button (" << button << ") received.";
@@ -75,15 +75,15 @@ int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
   return buttonflags;
 }
 
-Event::EventType GetTouchEventType(XEvent* xev) {
+ui::EventType GetTouchEventType(XEvent* xev) {
   XGenericEventCookie* cookie = &xev->xcookie;
   switch (cookie->evtype) {
     case XI_ButtonPress:
-      return Event::ET_TOUCH_PRESSED;
+      return ui::ET_TOUCH_PRESSED;
     case XI_ButtonRelease:
-      return Event::ET_TOUCH_RELEASED;
+      return ui::ET_TOUCH_RELEASED;
     case XI_Motion:
-      return Event::ET_TOUCH_MOVED;
+      return ui::ET_TOUCH_MOVED;
 
     // Note: We will not generate a _STATIONARY event here. It will be created,
     // when necessary, by a RWHVV.
@@ -93,7 +93,7 @@ Event::EventType GetTouchEventType(XEvent* xev) {
     // touch-sequence?
   }
 
-  return Event::ET_UNKNOWN;
+  return ui::ET_UNKNOWN;
 }
 
 gfx::Point GetTouchEventLocation(XEvent* xev) {
@@ -126,35 +126,35 @@ int GetMouseWheelOffset(XEvent* xev) {
   return xev->xbutton.button == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
 }
 
-Event::EventType GetMouseEventType(XEvent* xev) {
+ui::EventType GetMouseEventType(XEvent* xev) {
   switch (xev->type) {
     case ButtonPress:
-      return Event::ET_MOUSE_PRESSED;
+      return ui::ET_MOUSE_PRESSED;
     case ButtonRelease:
-      return Event::ET_MOUSE_RELEASED;
+      return ui::ET_MOUSE_RELEASED;
     case MotionNotify:
       if (xev->xmotion.state & (Button1Mask | Button2Mask | Button3Mask)) {
-        return Event::ET_MOUSE_DRAGGED;
+        return ui::ET_MOUSE_DRAGGED;
       }
-      return Event::ET_MOUSE_MOVED;
+      return ui::ET_MOUSE_MOVED;
 #if defined(HAVE_XINPUT2)
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(xev->xcookie.data);
       switch (xievent->evtype) {
         case XI_ButtonPress:
-          return Event::ET_MOUSE_PRESSED;
+          return ui::ET_MOUSE_PRESSED;
         case XI_ButtonRelease:
-          return Event::ET_MOUSE_RELEASED;
+          return ui::ET_MOUSE_RELEASED;
         case XI_Motion:
-          return GetButtonMaskForX2Event(xievent) ? Event::ET_MOUSE_DRAGGED :
-              Event::ET_MOUSE_MOVED;
+          return GetButtonMaskForX2Event(xievent) ? ui::ET_MOUSE_DRAGGED :
+              ui::ET_MOUSE_MOVED;
       }
     }
 #endif
   }
 
-  return Event::ET_UNKNOWN;
+  return ui::ET_UNKNOWN;
 }
 
 gfx::Point GetMouseEventLocation(XEvent* xev) {
@@ -214,7 +214,7 @@ int GetMouseEventFlags(XEvent* xev) {
 
 KeyEvent::KeyEvent(XEvent* xev)
     : Event(xev->type == KeyPress ?
-            Event::ET_KEY_PRESSED : Event::ET_KEY_RELEASED,
+            ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
             GetEventFlagsFromXState(xev->xkey.state)),
       key_code_(ui::KeyboardCodeFromXKeyEvent(xev)),
       repeat_count_(0),
@@ -229,7 +229,7 @@ MouseEvent::MouseEvent(XEvent* xev)
 }
 
 MouseWheelEvent::MouseWheelEvent(XEvent* xev)
-    : LocatedEvent(Event::ET_MOUSEWHEEL,
+    : LocatedEvent(ui::ET_MOUSEWHEEL,
                    GetMouseEventLocation(xev),
                    GetEventFlagsFromXState(xev->xbutton.state)),
       offset_(GetMouseWheelOffset(xev)) {
diff --git a/views/focus/accelerator_handler_touch.cc b/views/focus/accelerator_handler_touch.cc
index 6dcd040..65cc2e7 100644
--- a/views/focus/accelerator_handler_touch.cc
+++ b/views/focus/accelerator_handler_touch.cc
@@ -99,8 +99,8 @@ bool DispatchX2Event(RootView* root, XEvent* xev) {
       if (!touch_event) {
         // Show the cursor, and decide whether or not the cursor should be
         // automatically hidden after a certain time of inactivity.
-        int button_flags = mouseev.GetFlags() & (Event::EF_RIGHT_BUTTON_DOWN |
-            Event::EF_MIDDLE_BUTTON_DOWN | Event::EF_LEFT_BUTTON_DOWN);
+        int button_flags = mouseev.GetFlags() & (ui::EF_RIGHT_BUTTON_DOWN |
+            ui::EF_MIDDLE_BUTTON_DOWN | ui::EF_LEFT_BUTTON_DOWN);
         bool start_timer = false;
 
         switch (cookie->evtype) {
@@ -110,9 +110,9 @@ bool DispatchX2Event(RootView* root, XEvent* xev) {
           case XI_ButtonRelease:
             // For a release, start the timer if this was only button pressed
             // that is being released.
-            if (button_flags == Event::EF_RIGHT_BUTTON_DOWN ||
-                button_flags == Event::EF_LEFT_BUTTON_DOWN ||
-                button_flags == Event::EF_MIDDLE_BUTTON_DOWN)
+            if (button_flags == ui::EF_RIGHT_BUTTON_DOWN ||
+                button_flags == ui::EF_LEFT_BUTTON_DOWN ||
+                button_flags == ui::EF_MIDDLE_BUTTON_DOWN)
               start_timer = true;
             break;
           case XI_Motion:
@@ -130,7 +130,7 @@ bool DispatchX2Event(RootView* root, XEvent* xev) {
           root->OnMouseReleased(mouseev, false);
           return true;
         case XI_Motion: {
-          if (mouseev.GetType() == Event::ET_MOUSE_DRAGGED) {
+          if (mouseev.GetType() == ui::ET_MOUSE_DRAGGED) {
             return root->OnMouseDragged(mouseev);
           } else {
             root->OnMouseMoved(mouseev);
@@ -188,7 +188,7 @@ bool DispatchXEvent(XEvent* xev) {
 
       case MotionNotify: {
         MouseEvent mouseev(xev);
-        if (mouseev.GetType() == Event::ET_MOUSE_DRAGGED) {
+        if (mouseev.GetType() == ui::ET_MOUSE_DRAGGED) {
           return root->OnMouseDragged(mouseev);
         } else {
           root->OnMouseMoved(mouseev);
diff --git a/views/focus/accelerator_handler_win.cc b/views/focus/accelerator_handler_win.cc
index ce6cecd..b5e4c22 100644
--- a/views/focus/accelerator_handler_win.cc
+++ b/views/focus/accelerator_handler_win.cc
@@ -24,7 +24,7 @@ bool AcceleratorHandler::Dispatch(const MSG& msg) {
       switch (msg.message) {
         case WM_KEYDOWN:
         case WM_SYSKEYDOWN: {
-          KeyEvent event(Event::ET_KEY_PRESSED,
+          KeyEvent event(ui::ET_KEY_PRESSED,
                          ui::KeyboardCodeForWindowsKeyCode(msg.wParam),
                          KeyEvent::GetKeyStateFlags(),
                          msg.lParam & 0xFFFF,
diff --git a/views/focus/focus_manager.cc b/views/focus/focus_manager.cc
index d217e63..5e5b2f4 100644
--- a/views/focus/focus_manager.cc
+++ b/views/focus/focus_manager.cc
@@ -120,7 +120,7 @@ bool FocusManager::OnKeyEvent(const KeyEvent& event) {
 #endif
 
   // Intercept arrow key messages to switch between grouped views.
-  ui::KeyboardCode key_code = event.GetKeyCode();
+  ui::KeyboardCode key_code = event.key_code();
   if (focused_view_ && focused_view_->GetGroup() != -1 &&
       (key_code == ui::VKEY_UP || key_code == ui::VKEY_DOWN ||
        key_code == ui::VKEY_LEFT || key_code == ui::VKEY_RIGHT)) {
@@ -146,7 +146,7 @@ bool FocusManager::OnKeyEvent(const KeyEvent& event) {
   // Process keyboard accelerators.
   // If the key combination matches an accelerator, the accelerator is
   // triggered, otherwise the key event is processed as usual.
-  Accelerator accelerator(event.GetKeyCode(),
+  Accelerator accelerator(event.key_code(),
                           event.IsShiftDown(),
                           event.IsControlDown(),
                           event.IsAltDown());
@@ -509,8 +509,7 @@ AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
 
 // static
 bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
-  return key_event.GetKeyCode() == ui::VKEY_TAB &&
-         !key_event.IsControlDown();
+  return key_event.key_code() == ui::VKEY_TAB && !key_event.IsControlDown();
 }
 
 void FocusManager::ViewRemoved(View* parent, View* removed) {
diff --git a/views/focus/focus_manager_unittest.cc b/views/focus/focus_manager_unittest.cc
index bd21c16..457ed09 100644
--- a/views/focus/focus_manager_unittest.cc
+++ b/views/focus/focus_manager_unittest.cc
@@ -1448,12 +1448,12 @@ class MessageTrackingView : public View {
  }
 
   virtual bool OnKeyPressed(const KeyEvent& e) {
-    keys_pressed_.push_back(e.GetKeyCode());
+    keys_pressed_.push_back(e.key_code());
     return true;
   }
 
   virtual bool OnKeyReleased(const KeyEvent& e) {
-    keys_released_.push_back(e.GetKeyCode());
+    keys_released_.push_back(e.key_code());
     return true;
   }
 
diff --git a/views/native_types.h b/views/native_types.h
new file mode 100644
index 0000000..abea52e
--- /dev/null
+++ b/views/native_types.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2011 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 VIEWS_NATIVE_TYPES_H_
+#define VIEWS_NATIVE_TYPES_H_
+#pragma once
+
+#include "ui/gfx/native_widget_types.h"
+
+namespace views {
+
+#if defined(OS_WIN)
+typedef MSG NativeEvent;
+#endif
+#if defined(OS_LINUX)
+typedef union _GdkEvent GdkEvent;
+typedef GdkEvent* NativeEvent;
+#endif
+#if defined(TOUCH_UI)
+typedef union _XEvent XEvent;
+typedef XEvent* NativeEvent;
+#endif
+
+}  // namespace views
+
+#endif  // VIEWS_NATIVE_TYPES_H_
+
diff --git a/views/touchui/gesture_manager.cc b/views/touchui/gesture_manager.cc
index 46ee0da..bc4fdd5 100644
--- a/views/touchui/gesture_manager.cc
+++ b/views/touchui/gesture_manager.cc
@@ -30,25 +30,25 @@ bool GestureManager::ProcessTouchEventForGesture(const TouchEvent& event,
   // appear in a subsequent CL. This interim version permits verifying that the
   // event distribution code works by turning all touch inputs into
   // mouse approximations.
-  if (event.GetType() == Event::ET_TOUCH_PRESSED) {
+  if (event.GetType() == ui::ET_TOUCH_PRESSED) {
     DVLOG(1) << "GestureManager::ProcessTouchEventForGesture: TouchPressed";
-    MouseEvent mouse_event(Event::ET_MOUSE_PRESSED, event.x(), event.y(),
+    MouseEvent mouse_event(ui::ET_MOUSE_PRESSED, event.x(), event.y(),
                            event.GetFlags());
     source->OnMousePressed(mouse_event);
     return true;
   }
 
-  if (event.GetType() == Event::ET_TOUCH_RELEASED) {
+  if (event.GetType() == ui::ET_TOUCH_RELEASED) {
     DVLOG(1) << "GestureManager::ProcessTouchEventForGesture: TouchReleased";
-    MouseEvent mouse_event(Event::ET_MOUSE_RELEASED, event.x(), event.y(),
+    MouseEvent mouse_event(ui::ET_MOUSE_RELEASED, event.x(), event.y(),
                            event.GetFlags());
     source->OnMouseReleased(mouse_event, false);
     return true;
   }
 
-  if (event.GetType() == Event::ET_TOUCH_MOVED) {
+  if (event.GetType() == ui::ET_TOUCH_MOVED) {
     DVLOG(1) << "GestureManager::ProcessTouchEventForGesture: TouchMotion";
-    MouseEvent mouse_event(Event::ET_MOUSE_DRAGGED, event.x(), event.y(),
+    MouseEvent mouse_event(ui::ET_MOUSE_DRAGGED, event.x(), event.y(),
                            event.GetFlags());
     source->OnMouseDragged(mouse_event);
     return true;
diff --git a/views/view.cc b/views/view.cc
index f63f08f..d4ff9b1 100644
--- a/views/view.cc
+++ b/views/view.cc
@@ -672,7 +672,7 @@ View* View::GetViewForPoint(const gfx::Point& point) {
   return this;
 }
 
-gfx::NativeCursor View::GetCursorForPoint(Event::EventType event_type,
+gfx::NativeCursor View::GetCursorForPoint(ui::EventType event_type,
                                           const gfx::Point& p) {
   return NULL;
 }
diff --git a/views/view.h b/views/view.h
index 7205b4f32..f8f331a 100644
--- a/views/view.h
+++ b/views/view.h
@@ -570,7 +570,7 @@ class View : public AcceleratorTarget {
   // lifetime of the returned object, though that lifetime may vary from
   // platform to platform. On Windows, the cursor is a shared resource but in
   // Gtk, the framework destroys the returned cursor after setting it.
-  virtual gfx::NativeCursor GetCursorForPoint(Event::EventType event_type,
+  virtual gfx::NativeCursor GetCursorForPoint(ui::EventType event_type,
                                               const gfx::Point& p);
 
   // Convenience to test whether a point is within this view's bounds
diff --git a/views/view_unittest.cc b/views/view_unittest.cc
index d2dc693..bee547d 100644
--- a/views/view_unittest.cc
+++ b/views/view_unittest.cc
@@ -326,19 +326,19 @@ TEST_F(ViewTest, AddRemoveNotifications) {
 ////////////////////////////////////////////////////////////////////////////////
 
 bool TestView::OnMousePressed(const MouseEvent& event) {
-  last_mouse_event_type_ = event.GetType();
+  last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
   return true;
 }
 
 bool TestView::OnMouseDragged(const MouseEvent& event) {
-  last_mouse_event_type_ = event.GetType();
+  last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
   return true;
 }
 
 void TestView::OnMouseReleased(const MouseEvent& event, bool canceled) {
-  last_mouse_event_type_ = event.GetType();
+  last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
 }
 
@@ -364,12 +364,12 @@ TEST_F(ViewTest, MouseEvent) {
   v1->Reset();
   v2->Reset();
 
-  MouseEvent pressed(Event::ET_MOUSE_PRESSED,
+  MouseEvent pressed(ui::ET_MOUSE_PRESSED,
                      110,
                      120,
-                     Event::EF_LEFT_BUTTON_DOWN);
+                     ui::EF_LEFT_BUTTON_DOWN);
   root->OnMousePressed(pressed);
-  EXPECT_EQ(v2->last_mouse_event_type_, Event::ET_MOUSE_PRESSED);
+  EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_PRESSED);
   EXPECT_EQ(v2->location_.x(), 10);
   EXPECT_EQ(v2->location_.y(), 20);
   // Make sure v1 did not receive the event
@@ -378,12 +378,12 @@ TEST_F(ViewTest, MouseEvent) {
   // Drag event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  MouseEvent dragged(Event::ET_MOUSE_DRAGGED,
+  MouseEvent dragged(ui::ET_MOUSE_DRAGGED,
                      50,
                      40,
-                     Event::EF_LEFT_BUTTON_DOWN);
+                     ui::EF_LEFT_BUTTON_DOWN);
   root->OnMouseDragged(dragged);
-  EXPECT_EQ(v2->last_mouse_event_type_, Event::ET_MOUSE_DRAGGED);
+  EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_DRAGGED);
   EXPECT_EQ(v2->location_.x(), -50);
   EXPECT_EQ(v2->location_.y(), -60);
   // Make sure v1 did not receive the event
@@ -392,9 +392,9 @@ TEST_F(ViewTest, MouseEvent) {
   // Releasted event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  MouseEvent released(Event::ET_MOUSE_RELEASED, 0, 0, 0);
+  MouseEvent released(ui::ET_MOUSE_RELEASED, 0, 0, 0);
   root->OnMouseDragged(released);
-  EXPECT_EQ(v2->last_mouse_event_type_, Event::ET_MOUSE_RELEASED);
+  EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_RELEASED);
   EXPECT_EQ(v2->location_.x(), -100);
   EXPECT_EQ(v2->location_.y(), -100);
   // Make sure v1 did not receive the event
@@ -429,12 +429,12 @@ View::TouchStatus TestView::OnTouchEvent(const TouchEvent& event) {
   last_touch_event_type_ = event.GetType();
   location_.SetPoint(event.x(), event.y());
   if (!in_touch_sequence_) {
-    if (event.GetType() == Event::ET_TOUCH_PRESSED) {
+    if (event.GetType() == ui::ET_TOUCH_PRESSED) {
       in_touch_sequence_ = true;
       return TOUCH_STATUS_START;
     }
   } else {
-    if (event.GetType() == Event::ET_TOUCH_RELEASED) {
+    if (event.GetType() == ui::ET_TOUCH_RELEASED) {
       in_touch_sequence_ = false;
       return TOUCH_STATUS_END;
     }
@@ -474,7 +474,7 @@ TEST_F(ViewTest, TouchEvent) {
   v2->Reset();
   gm->Reset();
 
-  TouchEvent unhandled(Event::ET_TOUCH_MOVED,
+  TouchEvent unhandled(ui::ET_TOUCH_MOVED,
                        400,
                        400,
                        0, /* no flags */
@@ -485,7 +485,7 @@ TEST_F(ViewTest, TouchEvent) {
   EXPECT_EQ(v2->last_touch_event_type_, 0);
 
   EXPECT_EQ(gm->previously_handled_flag_, false);
-  EXPECT_EQ(gm->last_touch_event_, Event::ET_TOUCH_MOVED);
+  EXPECT_EQ(gm->last_touch_event_, ui::ET_TOUCH_MOVED);
   EXPECT_EQ(gm->last_view_, root);
   EXPECT_EQ(gm->dispatched_synthetic_event_, true);
 
@@ -494,7 +494,7 @@ TEST_F(ViewTest, TouchEvent) {
   v2->Reset();
   gm->Reset();
 
-  TouchEvent pressed(Event::ET_TOUCH_PRESSED,
+  TouchEvent pressed(ui::ET_TOUCH_PRESSED,
                      110,
                      120,
                      0, /* no flags */
@@ -502,7 +502,7 @@ TEST_F(ViewTest, TouchEvent) {
   v2->last_touch_event_was_handled_ = true;
   root->OnTouchEvent(pressed);
 
-  EXPECT_EQ(v2->last_touch_event_type_, Event::ET_TOUCH_PRESSED);
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_PRESSED);
   EXPECT_EQ(v2->location_.x(), 10);
   EXPECT_EQ(v2->location_.y(), 20);
   // Make sure v1 did not receive the event
@@ -516,13 +516,13 @@ TEST_F(ViewTest, TouchEvent) {
   // Drag event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  TouchEvent dragged(Event::ET_TOUCH_MOVED,
+  TouchEvent dragged(ui::ET_TOUCH_MOVED,
                      50,
                      40,
                      0, /* no flags */
                      0  /* first finger touch */);
   root->OnTouchEvent(dragged);
-  EXPECT_EQ(v2->last_touch_event_type_, Event::ET_TOUCH_MOVED);
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_MOVED);
   EXPECT_EQ(v2->location_.x(), -50);
   EXPECT_EQ(v2->location_.y(), -60);
   // Make sure v1 did not receive the event
@@ -535,10 +535,10 @@ TEST_F(ViewTest, TouchEvent) {
   // Released event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  TouchEvent released(Event::ET_TOUCH_RELEASED, 0, 0, 0, 0 /* first finger */);
+  TouchEvent released(ui::ET_TOUCH_RELEASED, 0, 0, 0, 0 /* first finger */);
   v2->last_touch_event_was_handled_ = true;
   root->OnTouchEvent(released);
-  EXPECT_EQ(v2->last_touch_event_type_, Event::ET_TOUCH_RELEASED);
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_RELEASED);
   EXPECT_EQ(v2->location_.x(), -100);
   EXPECT_EQ(v2->location_.y(), -100);
   // Make sure v1 did not receive the event
@@ -1270,7 +1270,7 @@ class DefaultButtonTest : public ViewTest {
   }
 
   void SimularePressingEnterAndCheckDefaultButton(ButtonID button_id) {
-    KeyEvent event(Event::ET_KEY_PRESSED, ui::VKEY_RETURN, 0, 0, 0);
+    KeyEvent event(ui::ET_KEY_PRESSED, ui::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 6010d99..83e33e8 100644
--- a/views/widget/root_view.cc
+++ b/views/widget/root_view.cc
@@ -386,8 +386,8 @@ bool RootView::OnMousePressed(const MouseEvent& e) {
   // are formed from a single-click followed by a double-click event. When the
   // double-click event lands on a different view than its single-click part,
   // we transform it into a single-click which prevents odd things.
-  if ((e.GetFlags() & MouseEvent::EF_IS_NON_CLIENT) &&
-      !(e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)) {
+  if ((e.flags() & ui::EF_IS_NON_CLIENT) &&
+      !(e.flags() & ui::EF_IS_DOUBLE_CLICK)) {
     last_click_handler_ = NULL;
     return false;
   }
@@ -424,8 +424,8 @@ bool RootView::OnMousePressed(const MouseEvent& e) {
     // Remove the double-click flag if the handler is different than the
     // one which got the first click part of the double-click.
     if (mouse_pressed_handler_ != last_click_handler_)
-      mouse_pressed_event.set_flags(e.GetFlags() &
-                                    ~MouseEvent::EF_IS_DOUBLE_CLICK);
+      mouse_pressed_event.set_flags(e.flags() &
+                                    ~ui::EF_IS_DOUBLE_CLICK);
 
     drag_info.Reset();
     bool handled = mouse_pressed_handler_->ProcessMousePressed(
@@ -469,7 +469,7 @@ bool RootView::OnMousePressed(const MouseEvent& e) {
   // entire hierarchy (even as a single-click when sent to a different view),
   // it must be marked as handled to avoid anything happening from default
   // processing if it the first click-part was handled by us.
-  if (last_click_handler_ && e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)
+  if (last_click_handler_ && e.flags() & ui::EF_IS_DOUBLE_CLICK)
     hit_disabled_view = true;
 
   last_click_handler_ = NULL;
@@ -508,7 +508,7 @@ void RootView::UpdateCursor(const MouseEvent& e) {
   if (v && v != this) {
     gfx::Point l(e.location());
     View::ConvertPointToView(this, v, &l);
-    cursor = v->GetCursorForPoint(e.GetType(), l);
+    cursor = v->GetCursorForPoint(e.type(), l);
   }
   SetActiveCursor(cursor);
 }
@@ -521,7 +521,7 @@ bool RootView::OnMouseDragged(const MouseEvent& e) {
 
     gfx::Point p;
     ConvertPointToMouseHandler(e.location(), &p);
-    MouseEvent mouse_event(e.GetType(), p.x(), p.y(), e.GetFlags());
+    MouseEvent mouse_event(e.type(), p.x(), p.y(), e.flags());
     return mouse_pressed_handler_->ProcessMouseDragged(mouse_event, &drag_info);
   }
   return false;
@@ -533,7 +533,7 @@ void RootView::OnMouseReleased(const MouseEvent& e, bool canceled) {
   if (mouse_pressed_handler_) {
     gfx::Point p;
     ConvertPointToMouseHandler(e.location(), &p);
-    MouseEvent mouse_released(e.GetType(), p.x(), p.y(), e.GetFlags());
+    MouseEvent mouse_released(e.type(), p.x(), p.y(), e.flags());
     // We allow the view to delete us from ProcessMouseReleased. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
@@ -555,20 +555,20 @@ void RootView::OnMouseMoved(const MouseEvent& e) {
   if (v && v != this) {
     if (v != mouse_move_handler_) {
       if (mouse_move_handler_ != NULL) {
-        MouseEvent exited_event(Event::ET_MOUSE_EXITED, 0, 0, 0);
+        MouseEvent exited_event(ui::ET_MOUSE_EXITED, 0, 0, 0);
         mouse_move_handler_->OnMouseExited(exited_event);
       }
 
       mouse_move_handler_ = v;
 
-      MouseEvent entered_event(Event::ET_MOUSE_ENTERED,
+      MouseEvent entered_event(ui::ET_MOUSE_ENTERED,
                                this,
                                mouse_move_handler_,
                                e.location(),
                                0);
       mouse_move_handler_->OnMouseEntered(entered_event);
     }
-    MouseEvent moved_event(Event::ET_MOUSE_MOVED,
+    MouseEvent moved_event(ui::ET_MOUSE_MOVED,
                            this,
                            mouse_move_handler_,
                            e.location(),
@@ -576,10 +576,10 @@ void RootView::OnMouseMoved(const MouseEvent& e) {
     mouse_move_handler_->OnMouseMoved(moved_event);
 
     gfx::NativeCursor cursor = mouse_move_handler_->GetCursorForPoint(
-        moved_event.GetType(), moved_event.location());
+        moved_event.type(), moved_event.location());
     SetActiveCursor(cursor);
   } else if (mouse_move_handler_ != NULL) {
-    MouseEvent exited_event(Event::ET_MOUSE_EXITED, 0, 0, 0);
+    MouseEvent exited_event(ui::ET_MOUSE_EXITED, 0, 0, 0);
     mouse_move_handler_->OnMouseExited(exited_event);
     SetActiveCursor(NULL);
   }
@@ -587,7 +587,7 @@ void RootView::OnMouseMoved(const MouseEvent& e) {
 
 void RootView::ProcessOnMouseExited() {
   if (mouse_move_handler_ != NULL) {
-    MouseEvent exited_event(Event::ET_MOUSE_EXITED, 0, 0, 0);
+    MouseEvent exited_event(ui::ET_MOUSE_EXITED, 0, 0, 0);
     mouse_move_handler_->OnMouseExited(exited_event);
     mouse_move_handler_ = NULL;
   }
@@ -602,7 +602,7 @@ void RootView::SetMouseHandler(View *new_mh) {
 void RootView::ProcessMouseDragCanceled() {
   if (mouse_pressed_handler_) {
     // Synthesize a release event.
-    MouseEvent release_event(Event::ET_MOUSE_RELEASED, last_mouse_event_x_,
+    MouseEvent release_event(ui::ET_MOUSE_RELEASED, last_mouse_event_x_,
                              last_mouse_event_y_, last_mouse_event_flags_);
     OnMouseReleased(release_event, true);
   }
@@ -680,18 +680,18 @@ 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() == ui::VKEY_APPS) ||
-     (event.GetKeyCode() == ui::VKEY_F10 && event.IsShiftDown()))) {
+  if (v && v->IsEnabled() && ((event.key_code() == ui::VKEY_APPS) ||
+     (event.key_code() == ui::VKEY_F10 && event.IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
     return true;
   }
   for (; v && v != this && !consumed; v = v->parent()) {
-    consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
+    consumed = (event.type() == ui::ET_KEY_PRESSED) ?
         v->OnKeyPressed(event) : v->OnKeyReleased(event);
   }
 
   if (!consumed && default_keyboard_handler_) {
-    consumed = (event.GetType() == Event::ET_KEY_PRESSED) ?
+    consumed = (event.type() == ui::ET_KEY_PRESSED) ?
         default_keyboard_handler_->OnKeyPressed(event) :
         default_keyboard_handler_->OnKeyReleased(event);
   }
@@ -758,7 +758,7 @@ void RootView::UnregisterViewForVisibleBoundsNotification(View* view) {
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& e) {
-  last_mouse_event_flags_ = e.GetFlags();
+  last_mouse_event_flags_ = e.flags();
   last_mouse_event_x_ = e.x();
   last_mouse_event_y_ = e.y();
 }
diff --git a/views/widget/widget_gtk.cc b/views/widget/widget_gtk.cc
index 730d6f7..d40ec45 100644
--- a/views/widget/widget_gtk.cc
+++ b/views/widget/widget_gtk.cc
@@ -883,7 +883,7 @@ bool WidgetGtk::HandleKeyboardEvent(GdkEventKey* event) {
     return false;
 
   KeyEvent key(event);
-  int key_code = key.GetKeyCode();
+  int key_code = key.key_code();
   bool handled = false;
 
   // Always reset |should_handle_menu_key_release_| unless we are handling a
@@ -901,7 +901,7 @@ bool WidgetGtk::HandleKeyboardEvent(GdkEventKey* event) {
     else
       should_handle_menu_key_release_ = true;
   } else if (key_code == ui::VKEY_MENU && should_handle_menu_key_release_ &&
-             (key.GetFlags() & ~Event::EF_ALT_DOWN) == 0) {
+             (key.flags() & ~ui::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(ui::VKEY_MENU, false, false, false);
@@ -916,20 +916,20 @@ int WidgetGtk::GetFlagsForEventButton(const GdkEventButton& event) {
   int flags = Event::GetFlagsFromGdkState(event.state);
   switch (event.button) {
     case 1:
-      flags |= Event::EF_LEFT_BUTTON_DOWN;
+      flags |= ui::EF_LEFT_BUTTON_DOWN;
       break;
     case 2:
-      flags |= Event::EF_MIDDLE_BUTTON_DOWN;
+      flags |= ui::EF_MIDDLE_BUTTON_DOWN;
       break;
     case 3:
-      flags |= Event::EF_RIGHT_BUTTON_DOWN;
+      flags |= ui::EF_RIGHT_BUTTON_DOWN;
       break;
     default:
       // We only deal with 1-3.
       break;
   }
   if (event.type == GDK_2BUTTON_PRESS)
-    flags |= MouseEvent::EF_IS_DOUBLE_CLICK;
+    flags |= ui::EF_IS_DOUBLE_CLICK;
   return flags;
 }
 
@@ -1078,10 +1078,10 @@ gboolean WidgetGtk::OnEnterNotify(GtkWidget* widget, GdkEventCrossing* event) {
     // modifiers is set. Unset it as we're compensating for the leave generated
     // when you press a button.
     int flags = (Event::GetFlagsFromGdkState(event->state) &
-                 ~(Event::EF_LEFT_BUTTON_DOWN |
-                   Event::EF_MIDDLE_BUTTON_DOWN |
-                   Event::EF_RIGHT_BUTTON_DOWN));
-    MouseEvent mouse_move(Event::ET_MOUSE_MOVED, x, y, flags);
+                 ~(ui::EF_LEFT_BUTTON_DOWN |
+                   ui::EF_MIDDLE_BUTTON_DOWN |
+                   ui::EF_RIGHT_BUTTON_DOWN));
+    MouseEvent mouse_move(ui::ET_MOUSE_MOVED, x, y, flags);
     root_view_->OnMouseMoved(mouse_move);
   }
 
@@ -1102,7 +1102,7 @@ gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
   if (has_capture_ && is_mouse_down_) {
     last_mouse_event_was_move_ = false;
     int flags = Event::GetFlagsFromGdkState(event->state);
-    MouseEvent mouse_drag(Event::ET_MOUSE_DRAGGED, x, y, flags);
+    MouseEvent mouse_drag(ui::ET_MOUSE_DRAGGED, x, y, flags);
     root_view_->OnMouseDragged(mouse_drag);
     return true;
   }
@@ -1116,7 +1116,7 @@ gboolean WidgetGtk::OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
   last_mouse_move_y_ = screen_loc.y();
   last_mouse_event_was_move_ = true;
   int flags = Event::GetFlagsFromGdkState(event->state);
-  MouseEvent mouse_move(Event::ET_MOUSE_MOVED, x, y, flags);
+  MouseEvent mouse_move(ui::ET_MOUSE_MOVED, x, y, flags);
   root_view_->OnMouseMoved(mouse_move);
   return true;
 }
@@ -1174,7 +1174,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() != ui::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+  if (key.key_code() != ui::VKEY_MENU || event->type != GDK_KEY_RELEASE)
     should_handle_menu_key_release_ = false;
 
   bool handled = false;
@@ -1308,7 +1308,7 @@ bool WidgetGtk::ProcessMousePressed(GdkEventButton* event) {
   int y = 0;
   GetContainedWidgetEventCoordinates(event, &x, &y);
   last_mouse_event_was_move_ = false;
-  MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED, x, y,
+  MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED, x, y,
                            GetFlagsForEventButton(*event));
 
   if (root_view_->OnMousePressed(mouse_pressed)) {
@@ -1327,7 +1327,7 @@ void WidgetGtk::ProcessMouseReleased(GdkEventButton* event) {
   GetContainedWidgetEventCoordinates(event, &x, &y);
 
   last_mouse_event_was_move_ = false;
-  MouseEvent mouse_up(Event::ET_MOUSE_RELEASED, x, y,
+  MouseEvent mouse_up(ui::ET_MOUSE_RELEASED, x, y,
                       GetFlagsForEventButton(*event));
   // Release the capture first, that way we don't get confused if
   // OnMouseReleased blocks.
diff --git a/views/widget/widget_win.cc b/views/widget/widget_win.cc
index d4e4267..bfa63b7 100644
--- a/views/widget/widget_win.cc
+++ b/views/widget/widget_win.cc
@@ -689,7 +689,7 @@ void WidgetWin::OnInitMenuPopup(HMENU menu,
 }
 
 void WidgetWin::OnKeyDown(TCHAR c, UINT rep_cnt, UINT flags) {
-  KeyEvent event(Event::ET_KEY_PRESSED, ui::KeyboardCodeForWindowsKeyCode(c),
+  KeyEvent event(ui::ET_KEY_PRESSED, ui::KeyboardCodeForWindowsKeyCode(c),
                  KeyEvent::GetKeyStateFlags(), rep_cnt, flags,
                  WM_KEYDOWN);
   RootView* root_view = GetFocusedViewRootView();
@@ -700,7 +700,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, ui::KeyboardCodeForWindowsKeyCode(c),
+  KeyEvent event(ui::ET_KEY_RELEASED, ui::KeyboardCodeForWindowsKeyCode(c),
                  KeyEvent::GetKeyStateFlags(), rep_cnt, flags,
                  WM_KEYUP);
   RootView* root_view = GetFocusedViewRootView();
@@ -1020,11 +1020,11 @@ bool WidgetWin::ProcessMousePressed(const CPoint& point,
   gfx::Point converted_point(point);
   if (non_client)
     View::ConvertPointToView(NULL, root_view_.get(), &converted_point);
-  MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED,
+  MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED,
                            converted_point.x(),
                            converted_point.y(),
-                           (dbl_click ? MouseEvent::EF_IS_DOUBLE_CLICK : 0) |
-                           (non_client ? MouseEvent::EF_IS_NON_CLIENT : 0) |
+                           (dbl_click ? ui::EF_IS_DOUBLE_CLICK : 0) |
+                           (non_client ? ui::EF_IS_NON_CLIENT : 0) |
                            Event::ConvertWindowsFlags(flags));
   if (root_view_->OnMousePressed(mouse_pressed)) {
     is_mouse_down_ = true;
@@ -1039,7 +1039,7 @@ bool WidgetWin::ProcessMousePressed(const CPoint& point,
 
 void WidgetWin::ProcessMouseDragged(const CPoint& point, UINT flags) {
   last_mouse_event_was_move_ = false;
-  MouseEvent mouse_drag(Event::ET_MOUSE_DRAGGED,
+  MouseEvent mouse_drag(ui::ET_MOUSE_DRAGGED,
                         point.x,
                         point.y,
                         Event::ConvertWindowsFlags(flags));
@@ -1048,7 +1048,7 @@ void WidgetWin::ProcessMouseDragged(const CPoint& point, UINT flags) {
 
 void WidgetWin::ProcessMouseReleased(const CPoint& point, UINT flags) {
   last_mouse_event_was_move_ = false;
-  MouseEvent mouse_up(Event::ET_MOUSE_RELEASED,
+  MouseEvent mouse_up(ui::ET_MOUSE_RELEASED,
                       point.x,
                       point.y,
                       Event::ConvertWindowsFlags(flags));
@@ -1082,7 +1082,7 @@ void WidgetWin::ProcessMouseMoved(const CPoint &point, UINT flags,
     last_mouse_move_x_ = screen_loc.x();
     last_mouse_move_y_ = screen_loc.y();
     last_mouse_event_was_move_ = true;
-    MouseEvent mouse_move(Event::ET_MOUSE_MOVED,
+    MouseEvent mouse_move(ui::ET_MOUSE_MOVED,
                           point.x,
                           point.y,
                           Event::ConvertWindowsFlags(flags));
diff --git a/views/window/window_gtk.cc b/views/window/window_gtk.cc
index 13a9764..e933e98 100644
--- a/views/window/window_gtk.cc
+++ b/views/window/window_gtk.cc
@@ -277,7 +277,7 @@ gboolean WindowGtk::OnButtonPress(GtkWidget* widget, GdkEventButton* event) {
       non_client_view_->NonClientHitTest(gfx::Point(x, y));
   switch (hittest_code) {
     case HTCAPTION: {
-      MouseEvent mouse_pressed(Event::ET_MOUSE_PRESSED, event->x, event->y,
+      MouseEvent mouse_pressed(ui::ET_MOUSE_PRESSED, event->x, event->y,
                                WidgetGtk::GetFlagsForEventButton(*event));
       // Start dragging if the mouse event is a single click and *not* a right
       // click. If it is a right click, then pass it through to
author	ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2011-02-10 04:56:36 +0000
committer	ben@chromium.org <ben@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2011-02-10 04:56:36 +0000
commit	8d577a70f6e6d2e47f0ac32f8606e489a7a77998 (patch)
tree	48eae3f525e0323362db629efa2589e70a5a4e49
parent	8fb0ecf45b286845fd2004a157a294d7e3ca7a39 (diff)
download	chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.zip chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.tar.gz chromium_src-8d577a70f6e6d2e47f0ac32f8606e489a7a77998.tar.bz2