Reverting this CL to fix the interactive ui test failures.

Revert 42498 - Keyboard accessibility for the page and app menus.
Works on Windows, and on Linux with toolkit_views.

The goal is to make Chrome behave more like a standard Windows
application, for users who rely on the keyboard and expect standard
keyboard accelerators to work.

Pressing F10, or pressing and releasing Alt, will set focus to the
Page menu, as if it was the first item in a menu bar.

Pressing enter, space, up arrow, or down arrow will open the focused menu.
Once a menu is opened, pressing left and right arrows will switch between
the two menus. Pressing escape will return focus to the title of the
previously open menu.

A new UI test attempts to select something from the menus using only the
keyboard. It works on Linux (with toolkit_views) and on Windows.

BUG=none
TEST=New keyboard accessibility interactive ui test.

Review URL: http://codereview.chromium.org/660323

TBR=dmazzoni@chromium.org
Review URL: http://codereview.chromium.org/1428001

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

19 files changed, 36 insertions, 545 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 226f89c..dfb84ba 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -140,8 +140,7 @@ class ClickTask : public Task {
 AutomationProvider::AutomationProvider(Profile* profile)
     : redirect_query_(0),
       profile_(profile),
-      reply_message_(NULL),
-      popup_menu_waiter_(NULL) {
+      reply_message_(NULL) {
   browser_tracker_.reset(new AutomationBrowserTracker(this));
   tab_tracker_.reset(new AutomationTabTracker(this));
   window_tracker_.reset(new AutomationWindowTracker(this));
@@ -499,14 +498,6 @@ void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_LoginWithUserAndPass,
                                     LoginWithUserAndPass)
 #endif
-#if defined(TOOLKIT_VIEWS)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForFocusedViewIDToChange,
-                                    WaitForFocusedViewIDToChange)
-    IPC_MESSAGE_HANDLER(AutomationMsg_StartTrackingPopupMenus,
-                        StartTrackingPopupMenus)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForPopupMenuToOpen,
-                                    WaitForPopupMenuToOpen)
-#endif
     IPC_MESSAGE_HANDLER(AutomationMsg_RemoveBrowsingData, RemoveBrowsingData)
   IPC_END_MESSAGE_MAP()
 }
@@ -2548,23 +2539,3 @@ void AutomationProvider::SetContentSetting(
     *success = true;
   }
 }
-
-#if !defined(TOOLKIT_VIEWS)
-void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
-  NOTIMPLEMENTED();
-};
-
-void AutomationProvider::WaitForFocusedViewIDToChange(
-    int handle, int previous_view_id, IPC::Message* reply_message) {
-  NOTIMPLEMENTED();
-}
-
-void AutomationProvider::StartTrackingPopupMenus(
-    int browser_handle, bool* success) {
-  NOTIMPLEMENTED();
-}
-
-void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
-  NOTIMPLEMENTED();
-}
-#endif  // !defined(TOOLKIT_VIEWS)
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h
index 2d680b1..6da47e2 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -35,7 +35,6 @@
 #endif  // defined(OS_WIN)
 
 struct AutomationMsg_Find_Params;
-class PopupMenuWaiter;
 
 namespace IPC {
 struct Reposition_Params;
@@ -134,7 +133,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
 
  protected:
   friend class base::RefCounted<AutomationProvider>;
-  friend class PopupMenuWaiter;
   virtual ~AutomationProvider();
 
  private:
@@ -584,22 +582,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   // Returns NULL on failure.
   RenderViewHost* GetViewForTab(int tab_handle);
 
-  // Block until the focused view ID changes to something other than
-  // previous_view_id.
-  void WaitForFocusedViewIDToChange(int handle,
-                                    int previous_view_id,
-                                    IPC::Message* reply_message);
-
-  // Start tracking popup menus. Must be called before executing the
-  // command that might open the popup menu; then call WaitForPopupMenuToOpen.
-  void StartTrackingPopupMenus(int browser_handle, bool* success);
-
-  // Wait until a popup menu has opened.
-  void WaitForPopupMenuToOpen(IPC::Message* reply_message);
-
-  // Method called by the popup menu tracker when a popup menu is opened.
-  void NotifyPopupMenuOpened();
-
   typedef ObserverList<NotificationObserver> NotificationObserverList;
   typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
   typedef std::map<int, ExtensionPortContainer*> PortContainerMap;
@@ -635,13 +617,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
 
   IPC::Message* reply_message_;
 
-  // Keep track of whether a popup menu has been opened since the last time
-  // that StartTrackingPopupMenus has been called.
-  bool popup_menu_opened_;
-
-  // A temporary object that receives a notification when a popup menu opens.
-  PopupMenuWaiter* popup_menu_waiter_;
-
   DISALLOW_COPY_AND_ASSIGN(AutomationProvider);
 };
 
diff --git a/chrome/browser/automation/automation_provider_gtk.cc b/chrome/browser/automation/automation_provider_gtk.cc
index 62b378f..601e81a 100644
--- a/chrome/browser/automation/automation_provider_gtk.cc
+++ b/chrome/browser/automation/automation_provider_gtk.cc
@@ -79,6 +79,10 @@ void AutomationProvider::IsWindowMaximized(int handle, bool* is_maximized,
   NOTIMPLEMENTED();
 }
 
+void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
+  NOTIMPLEMENTED();
+}
+
 void AutomationProvider::PrintAsync(int tab_handle) {
   NOTIMPLEMENTED();
 }
@@ -223,3 +227,4 @@ void AutomationProvider::GetWindowTitle(int handle, string16* text) {
   const gchar* title = gtk_window_get_title(window);
   text->assign(UTF8ToUTF16(title));
 }
+
diff --git a/chrome/browser/automation/automation_provider_mac.mm b/chrome/browser/automation/automation_provider_mac.mm
index 2d3f3c5..f58b7a8 100644
--- a/chrome/browser/automation/automation_provider_mac.mm
+++ b/chrome/browser/automation/automation_provider_mac.mm
@@ -66,6 +66,10 @@ void AutomationProvider::IsWindowMaximized(int handle, bool* is_maximized,
   NOTIMPLEMENTED();
 }
 
+void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
+  NOTIMPLEMENTED();
+}
+
 void AutomationProvider::PrintAsync(int tab_handle) {
   NOTIMPLEMENTED();
 }
@@ -154,3 +158,4 @@ void AutomationProvider::GetWindowTitle(int handle, string16* text) {
 
   text->assign(base::SysNSStringToUTF16(title));
 }
+
diff --git a/chrome/browser/automation/automation_provider_views.cc b/chrome/browser/automation/automation_provider_views.cc
index f7a461c..f161105 100644
--- a/chrome/browser/automation/automation_provider_views.cc
+++ b/chrome/browser/automation/automation_provider_views.cc
@@ -4,12 +4,7 @@
 
 #include "chrome/browser/automation/automation_provider.h"
 
-#include "chrome/browser/views/frame/browser_view.h"
-#include "chrome/browser/views/toolbar_view.h"
-#include "chrome/test/automation/automation_messages.h"
 #include "gfx/point.h"
-#include "views/controls/menu/menu_wrapper.h"
-#include "views/focus/focus_manager.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
@@ -39,150 +34,3 @@ void AutomationProvider::WindowGetViewBounds(int handle, int view_id,
   }
 }
 
-void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
-  *view_id = -1;
-  if (window_tracker_->ContainsHandle(handle)) {
-    gfx::NativeWindow window = window_tracker_->GetResource(handle);
-    views::FocusManager* focus_manager =
-        views::FocusManager::GetFocusManagerForNativeWindow(window);
-    DCHECK(focus_manager);
-    views::View* focused_view = focus_manager->GetFocusedView();
-    if (focused_view)
-      *view_id = focused_view->GetID();
-  }
-}
-
-// Helper class that waits until the focus has changed to a view other
-// than the one with the provided view id.
-class ViewFocusChangeWaiter : public views::FocusChangeListener {
- public:
-  ViewFocusChangeWaiter(views::FocusManager* focus_manager,
-                        int previous_view_id,
-                        AutomationProvider* automation,
-                        IPC::Message* reply_message)
-      : focus_manager_(focus_manager),
-        previous_view_id_(previous_view_id),
-        automation_(automation),
-        reply_message_(reply_message),
-        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
-    focus_manager_->AddFocusChangeListener(this);
-    // Call the focus change notification once in case the focus has
-    // already changed.
-    FocusWillChange(NULL, focus_manager_->GetFocusedView());
-  }
-
-  ~ViewFocusChangeWaiter() {
-    focus_manager_->RemoveFocusChangeListener(this);
-  }
-
-  // Inherited from FocusChangeListener
-  virtual void FocusWillChange(views::View* focused_before,
-                               views::View* focused_now) {
-    // This listener is called before focus actually changes. Post a task
-    // that will get run after focus changes.
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &ViewFocusChangeWaiter::FocusChanged,
-            focused_before,
-            focused_now));
-  }
-
- private:
-  void FocusChanged(views::View* focused_before,
-                    views::View* focused_now) {
-    if (focused_now && focused_now->GetID() != previous_view_id_) {
-      AutomationMsg_WaitForFocusedViewIDToChange::WriteReplyParams(
-          reply_message_, true, focused_now->GetID());
-
-      automation_->Send(reply_message_);
-      delete this;
-    }
-  }
-
-  views::FocusManager* focus_manager_;
-  int previous_view_id_;
-  AutomationProvider* automation_;
-  IPC::Message* reply_message_;
-  ScopedRunnableMethodFactory<ViewFocusChangeWaiter> method_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(ViewFocusChangeWaiter);
-};
-
-void AutomationProvider::WaitForFocusedViewIDToChange(
-    int handle, int previous_view_id, IPC::Message* reply_message) {
-  if (!window_tracker_->ContainsHandle(handle))
-    return;
-  gfx::NativeWindow window = window_tracker_->GetResource(handle);
-  views::FocusManager* focus_manager =
-      views::FocusManager::GetFocusManagerForNativeWindow(window);
-
-  // The waiter will respond to the IPC and delete itself when done.
-  new ViewFocusChangeWaiter(focus_manager,
-                            previous_view_id,
-                            this,
-                            reply_message);
-}
-
-class PopupMenuWaiter : public views::MenuListener {
- public:
-  PopupMenuWaiter(ToolbarView* toolbar_view,
-                  AutomationProvider* automation)
-      : toolbar_view_(toolbar_view),
-        automation_(automation),
-        reply_message_(NULL) {
-    toolbar_view_->AddMenuListener(this);
-  }
-
-  // Implementation of views::MenuListener
-  virtual void OnMenuOpened() {
-    toolbar_view_->RemoveMenuListener(this);
-    automation_->popup_menu_opened_ = true;
-    automation_->popup_menu_waiter_ = NULL;
-    if (reply_message_) {
-      AutomationMsg_WaitForPopupMenuToOpen::WriteReplyParams(
-          reply_message_, true);
-      automation_->Send(reply_message_);
-    }
-    delete this;
-  }
-
-  void set_reply_message(IPC::Message* reply_message) {
-    reply_message_ = reply_message;
-  }
-
- private:
-  ToolbarView* toolbar_view_;
-  AutomationProvider* automation_;
-  IPC::Message* reply_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(PopupMenuWaiter);
-};
-
-void AutomationProvider::StartTrackingPopupMenus(
-    int browser_handle, bool* success) {
-  if (browser_tracker_->ContainsHandle(browser_handle)) {
-    Browser* browser = browser_tracker_->GetResource(browser_handle);
-    BrowserView* browser_view = reinterpret_cast<BrowserView*>(
-        browser->window());
-    ToolbarView* toolbar_view = browser_view->GetToolbarView();
-    popup_menu_opened_ = false;
-    popup_menu_waiter_ = new PopupMenuWaiter(toolbar_view, this);
-    *success = true;
-  }
-}
-
-void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
-  // See if the menu already opened and return true if so.
-  if (popup_menu_opened_) {
-    AutomationMsg_WaitForPopupMenuToOpen::WriteReplyParams(
-          reply_message, true);
-    Send(reply_message);
-    return;
-  }
-
-  // Otherwise, register this reply message with the waiter,
-  // which will handle responding to this IPC when the popup
-  // menu opens.
-  popup_menu_waiter_->set_reply_message(reply_message);
-}
diff --git a/chrome/browser/automation/automation_provider_win.cc b/chrome/browser/automation/automation_provider_win.cc
index 2139420..9539498 100644
--- a/chrome/browser/automation/automation_provider_win.cc
+++ b/chrome/browser/automation/automation_provider_win.cc
@@ -231,6 +231,19 @@ void AutomationProvider::WindowSimulateDrag(int handle,
   }
 }
 
+void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
+  *view_id = -1;
+  if (window_tracker_->ContainsHandle(handle)) {
+    HWND hwnd = window_tracker_->GetResource(handle);
+    views::FocusManager* focus_manager =
+        views::FocusManager::GetFocusManagerForNativeView(hwnd);
+    DCHECK(focus_manager);
+    views::View* focused_view = focus_manager->GetFocusedView();
+    if (focused_view)
+      *view_id = focused_view->GetID();
+  }
+}
+
 void AutomationProvider::GetWindowBounds(int handle, gfx::Rect* bounds,
                                          bool* success) {
   *success = false;
diff --git a/chrome/browser/automation/ui_controls_win.cc b/chrome/browser/automation/ui_controls_win.cc
index aba7248..3ff1a5c 100644
--- a/chrome/browser/automation/ui_controls_win.cc
+++ b/chrome/browser/automation/ui_controls_win.cc
@@ -166,21 +166,6 @@ bool SendKeyPressImpl(base::KeyboardCode key,
   scoped_refptr<InputDispatcher> dispatcher(
       task ? new InputDispatcher(task, WM_KEYUP) : NULL);
 
-  // If a pop-up menu is open, it won't receive events sent using SendInput.
-  // Check for a pop-up menu using its window class (#32768) and if one
-  // exists, send the key event directly there.
-  HWND popup_menu = ::FindWindow(L"#32768", 0);
-  if (popup_menu != NULL) {
-    WPARAM w_param = win_util::KeyboardCodeToWin(key);
-    LPARAM l_param = 0;
-    ::SendMessage(popup_menu, WM_KEYDOWN, w_param, l_param);
-    ::SendMessage(popup_menu, WM_KEYUP, w_param, l_param);
-
-    if (dispatcher.get())
-      dispatcher->AddRef();
-    return true;
-  }
-
   INPUT input[8] = { 0 }; // 8, assuming all the modifiers are activated
 
   int i = 0;
diff --git a/chrome/browser/browser.cc b/chrome/browser/browser.cc
index 0f7b25f..2f80049 100644
--- a/chrome/browser/browser.cc
+++ b/chrome/browser/browser.cc
@@ -874,9 +874,6 @@ void Browser::UpdateCommandsForFullscreenMode(bool is_fullscreen) {
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_TOOLBAR, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_LOCATION, show_main_ui);
   command_updater_.UpdateCommandEnabled(IDC_FOCUS_SEARCH, show_main_ui);
-  command_updater_.UpdateCommandEnabled(
-      IDC_FOCUS_MENU_BAR,
-      show_main_ui && !is_fullscreen && (type() & TYPE_POPUP) == 0);
 
   // Show various bits of UI
   command_updater_.UpdateCommandEnabled(IDC_DEVELOPER_MENU, show_main_ui);
@@ -1330,12 +1327,6 @@ void Browser::FocusToolbar() {
   window_->FocusToolbar();
 }
 
-void Browser::FocusPageAndAppMenus() {
-  UserMetrics::RecordAction(
-      UserMetricsAction("FocusPageAndAppMenus"), profile_);
-  window_->FocusPageAndAppMenus();
-}
-
 void Browser::FocusLocationBar() {
   UserMetrics::RecordAction(UserMetricsAction("FocusLocation"), profile_);
   window_->SetFocusToLocationBar();
@@ -1766,7 +1757,6 @@ void Browser::ExecuteCommandWithDisposition(
     case IDC_FOCUS_TOOLBAR:         FocusToolbar();                break;
     case IDC_FOCUS_LOCATION:        FocusLocationBar();            break;
     case IDC_FOCUS_SEARCH:          FocusSearch();                 break;
-    case IDC_FOCUS_MENU_BAR:        FocusPageAndAppMenus();        break;
 
     // Show various bits of UI
     case IDC_OPEN_FILE:             OpenFile();                    break;
diff --git a/chrome/browser/browser.h b/chrome/browser/browser.h
index fad8295..51470f7 100644
--- a/chrome/browser/browser.h
+++ b/chrome/browser/browser.h
@@ -460,7 +460,6 @@ class Browser : public TabStripModelDelegate,
   void FocusToolbar();
   void FocusLocationBar();
   void FocusSearch();
-  void FocusPageAndAppMenus();
 
   // Show various bits of UI
   void OpenFile();
diff --git a/chrome/browser/browser_window.h b/chrome/browser/browser_window.h
index e0d7001..484e6bb 100644
--- a/chrome/browser/browser_window.h
+++ b/chrome/browser/browser_window.h
@@ -142,11 +142,6 @@ class BrowserWindow {
   // Focuses the toolbar (for accessibility).
   virtual void FocusToolbar() = 0;
 
-  // Focuses the page and app menus like they were a menu bar.
-  //
-  // Not used on the Mac, which has a "normal" menu bar.
-  virtual void FocusPageAndAppMenus() = 0;
-
   // Returns whether the bookmark bar is visible or not.
   virtual bool IsBookmarkBarVisible() const = 0;
 
diff --git a/chrome/browser/cocoa/browser_window_cocoa.h b/chrome/browser/cocoa/browser_window_cocoa.h
index 753a645..dde965e 100644
--- a/chrome/browser/cocoa/browser_window_cocoa.h
+++ b/chrome/browser/cocoa/browser_window_cocoa.h
@@ -57,7 +57,6 @@ class BrowserWindowCocoa : public BrowserWindow,
   virtual void UpdateToolbar(TabContents* contents,
                              bool should_restore_state);
   virtual void FocusToolbar();
-  virtual void FocusPageAndAppMenus();
   virtual bool IsBookmarkBarVisible() const;
   virtual bool IsBookmarkBarAnimating() const;
   virtual bool IsToolbarVisible() const;
diff --git a/chrome/browser/cocoa/browser_window_cocoa.mm b/chrome/browser/cocoa/browser_window_cocoa.mm
index a425f79..4972eae 100644
--- a/chrome/browser/cocoa/browser_window_cocoa.mm
+++ b/chrome/browser/cocoa/browser_window_cocoa.mm
@@ -223,10 +223,6 @@ void BrowserWindowCocoa::FocusToolbar() {
   NOTIMPLEMENTED();
 }
 
-void BrowserWindowCocoa::FocusPageAndAppMenus() {
-  // Chrome uses the standard Mac OS X menu bar, so this isn't needed.
-}
-
 bool BrowserWindowCocoa::IsBookmarkBarVisible() const {
   return browser_->profile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
diff --git a/chrome/browser/gtk/browser_window_gtk.cc b/chrome/browser/gtk/browser_window_gtk.cc
index 078c548..b128621 100644
--- a/chrome/browser/gtk/browser_window_gtk.cc
+++ b/chrome/browser/gtk/browser_window_gtk.cc
@@ -786,10 +786,6 @@ void BrowserWindowGtk::FocusToolbar() {
   NOTIMPLEMENTED();
 }
 
-void BrowserWindowGtk::FocusPageAndAppMenus() {
-  NOTIMPLEMENTED();
-}
-
 bool BrowserWindowGtk::IsBookmarkBarVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR) &&
       bookmark_bar_.get() &&
diff --git a/chrome/browser/gtk/browser_window_gtk.h b/chrome/browser/gtk/browser_window_gtk.h
index bac7a3d..cbc9270 100644
--- a/chrome/browser/gtk/browser_window_gtk.h
+++ b/chrome/browser/gtk/browser_window_gtk.h
@@ -75,7 +75,6 @@ class BrowserWindowGtk : public BrowserWindow,
   virtual void UpdateToolbar(TabContents* contents,
                              bool should_restore_state);
   virtual void FocusToolbar();
-  virtual void FocusPageAndAppMenus();
   virtual bool IsBookmarkBarVisible() const;
   virtual bool IsBookmarkBarAnimating() const;
   virtual bool IsToolbarVisible() const;
diff --git a/chrome/browser/views/accelerator_table_gtk.cc b/chrome/browser/views/accelerator_table_gtk.cc
index f3a7a54..28a630b 100644
--- a/chrome/browser/views/accelerator_table_gtk.cc
+++ b/chrome/browser/views/accelerator_table_gtk.cc
@@ -20,8 +20,6 @@ const AcceleratorMapping kAcceleratorMap[] = {
   { base::VKEY_L, false, true, false, IDC_FOCUS_LOCATION },
   { base::VKEY_D, false, false, true, IDC_FOCUS_LOCATION },
   { base::VKEY_F6, false, false, false, IDC_FOCUS_LOCATION },
-  { base::VKEY_F10, false, false, false, IDC_FOCUS_MENU_BAR },
-  { base::VKEY_MENU, false, false, false, IDC_FOCUS_MENU_BAR },
 
   // Tab/window controls.
   { base::VKEY_T, false, true, false, IDC_NEW_TAB },
diff --git a/chrome/browser/views/frame/browser_view.cc b/chrome/browser/views/frame/browser_view.cc
index 1144b13..9d62c70 100644
--- a/chrome/browser/views/frame/browser_view.cc
+++ b/chrome/browser/views/frame/browser_view.cc
@@ -638,10 +638,10 @@ void BrowserView::TraverseNextAccessibleToolbar(bool forward) {
   // TODO(mohamed) This needs to be smart, that applies to all toolbars.
   //               Currently it just traverses between bookmarks and toolbar.
   if (!forward && toolbar_->IsVisible() && toolbar_->IsEnabled()) {
-    toolbar_->RequestFocus();
+    toolbar_->InitiateTraversal(last_focused_view_storage_id_);
   } else if (forward && bookmark_bar_view_->IsVisible() &&
              bookmark_bar_view_->IsEnabled()) {
-    bookmark_bar_view_->RequestFocus();
+    bookmark_bar_view_->InitiateTraversal(last_focused_view_storage_id_);
   }
 }
 
@@ -850,31 +850,17 @@ void BrowserView::UpdateToolbar(TabContents* contents,
 }
 
 void BrowserView::FocusToolbar() {
-  // Start the traversal within the main toolbar, passing it the storage id
-  // of the view where focus should be returned if the user exits the toolbar.
-  SaveFocusedView();
-  toolbar_->InitiateTraversal(last_focused_view_storage_id_);
-}
-
-void BrowserView::FocusPageAndAppMenus() {
-  // Chrome doesn't have a traditional menu bar, but it has menu buttons in
-  // the main toolbar that play the same role.  If the user presses a key
-  // that would typically focus the menu bar, tell the toolbar to focus
-  // the first menu button.  Pass it the storage id of the view where
-  // focus should be returned if the user presses escape.
-  //
-  // Not used on the Mac, which has a normal menu bar.
-  SaveFocusedView();
-  toolbar_->EnterMenuBarEmulationMode(last_focused_view_storage_id_, NULL);
-}
-
-void BrowserView::SaveFocusedView() {
+  // Remove existing views in the storage, traversal should be restarted.
   views::ViewStorage* view_storage = views::ViewStorage::GetSharedInstance();
   if (view_storage->RetrieveView(last_focused_view_storage_id_))
     view_storage->RemoveView(last_focused_view_storage_id_);
-  views::View* focused_view = GetRootView()->GetFocusedView();
-  if (focused_view)
-    view_storage->StoreView(last_focused_view_storage_id_, focused_view);
+
+  // Store the last focused view into the storage, to handle existing traversal.
+  view_storage->StoreView(last_focused_view_storage_id_,
+                          GetRootView()->GetFocusedView());
+
+  // Start the traversal within the main toolbar.
+  toolbar_->InitiateTraversal(last_focused_view_storage_id_);
 }
 
 void BrowserView::DestroyBrowser() {
diff --git a/chrome/browser/views/frame/browser_view.h b/chrome/browser/views/frame/browser_view.h
index fb020a0..8846787 100644
--- a/chrome/browser/views/frame/browser_view.h
+++ b/chrome/browser/views/frame/browser_view.h
@@ -270,7 +270,6 @@ class BrowserView : public BrowserBubbleHost,
   virtual void UpdateStopGoState(bool is_loading, bool force);
   virtual void UpdateToolbar(TabContents* contents, bool should_restore_state);
   virtual void FocusToolbar();
-  virtual void FocusPageAndAppMenus();
   virtual void DestroyBrowser();
   virtual bool IsBookmarkBarVisible() const;
   virtual bool IsBookmarkBarAnimating() const;
@@ -473,9 +472,6 @@ class BrowserView : public BrowserBubbleHost,
   // Initialize the hung plugin detector.
   void InitHangMonitor();
 
-  // Save the current focused view to view storage
-  void SaveFocusedView();
-
   // Initialize class statics.
   static void InitClass();
 
diff --git a/chrome/browser/views/toolbar_view.cc b/chrome/browser/views/toolbar_view.cc
index b0cffa6..81b264db 100644
--- a/chrome/browser/views/toolbar_view.cc
+++ b/chrome/browser/views/toolbar_view.cc
@@ -34,7 +34,6 @@
 #include "chrome/browser/views/bookmark_menu_button.h"
 #include "chrome/browser/views/browser_actions_container.h"
 #include "chrome/browser/views/event_utils.h"
-#include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/go_button.h"
 #include "chrome/browser/views/location_bar_view.h"
 #include "chrome/browser/views/toolbar_star_toggle.h"
@@ -53,8 +52,6 @@
 #include "views/controls/label.h"
 #include "views/controls/menu/menu_2.h"
 #include "views/drag_utils.h"
-#include "views/focus/view_storage.h"
-#include "views/widget/tooltip_manager.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
@@ -93,9 +90,7 @@ ToolbarView::ToolbarView(Browser* browser)
       bookmark_menu_(NULL),
       profile_(NULL),
       browser_(browser),
-      profiles_menu_contents_(NULL),
-      last_focused_view_storage_id_(-1),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      profiles_menu_contents_(NULL) {
   SetID(VIEW_ID_TOOLBAR);
   browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
   browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
@@ -113,14 +108,6 @@ ToolbarView::ToolbarView(Browser* browser)
   }
 }
 
-ToolbarView::~ToolbarView() {
-  if (page_menu_->HasFocus() || app_menu_->HasFocus()) {
-    views::FocusManager* focus_manager = GetFocusManager();
-    focus_manager->UnregisterAccelerators(this);
-    focus_manager->RemoveFocusChangeListener(this);
-  }
-}
-
 void ToolbarView::Init(Profile* profile) {
   back_menu_model_.reset(new BackForwardMenuModel(
       browser_, BackForwardMenuModel::BACKWARD_MENU));
@@ -161,82 +148,6 @@ void ToolbarView::SetAppMenuModel(AppMenuModel* model) {
   app_menu_menu_.reset(new views::Menu2(app_menu_model_.get()));
 }
 
-void ToolbarView::EnterMenuBarEmulationMode(int last_focused_view_storage_id,
-                                            views::MenuButton* menu_to_focus) {
-  last_focused_view_storage_id_ = last_focused_view_storage_id;
-  if (!menu_to_focus)
-    menu_to_focus = page_menu_;
-
-  // If we're already in the menu bar emulation mode, just set the focus.
-  if (page_menu_->IsFocusable() && app_menu_->IsFocusable()) {
-    menu_to_focus->RequestFocus();
-    return;
-  }
-
-  // Make the menus focusable and set focus to the initial menu.
-  page_menu_->SetFocusable(true);
-  app_menu_->SetFocusable(true);
-  menu_to_focus->RequestFocus();
-
-  // Listen so we know when focus has moved to something other than one
-  // of these menus.
-  views::FocusManager* focus_manager = GetFocusManager();
-  focus_manager->AddFocusChangeListener(this);
-
-  // Add accelerators so that the usual keys used to interact with a
-  // menu bar work as expected.
-  views::Accelerator return_key(base::VKEY_RETURN, false, false, false);
-  focus_manager->RegisterAccelerator(return_key, this);
-  views::Accelerator space(base::VKEY_SPACE, false, false, false);
-  focus_manager->RegisterAccelerator(space, this);
-  views::Accelerator escape(base::VKEY_ESCAPE, false, false, false);
-  focus_manager->RegisterAccelerator(escape, this);
-  views::Accelerator down(base::VKEY_DOWN, false, false, false);
-  focus_manager->RegisterAccelerator(down, this);
-  views::Accelerator up(base::VKEY_UP, false, false, false);
-  focus_manager->RegisterAccelerator(up, this);
-  views::Accelerator left(base::VKEY_LEFT, false, false, false);
-  focus_manager->RegisterAccelerator(left, this);
-  views::Accelerator right(base::VKEY_RIGHT, false, false, false);
-  focus_manager->RegisterAccelerator(right, this);
-}
-
-void ToolbarView::AddMenuListener(views::MenuListener* listener) {
-  menu_listeners_.push_back(listener);
-}
-
-void ToolbarView::RemoveMenuListener(views::MenuListener* listener) {
-  for (std::vector<views::MenuListener*>::iterator iter =
-      menu_listeners_.begin();
-    iter != menu_listeners_.end();
-    ++iter) {
-      if (*iter == listener) {
-        menu_listeners_.erase(iter);
-        return;
-      }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// ToolbarView, FocusChangeListener overrides:
-
-void ToolbarView::FocusWillChange(views::View* focused_before,
-                                  views::View* focused_now) {
-  // If the focus is switching to something outside the menu bar,
-  // take it out of the focus traversal.
-  if (focused_now != NULL &&
-      focused_now != page_menu_ &&
-      focused_now != app_menu_) {
-    // Post ExitMenuBarEmulationMode to the queue rather than running it
-    // right away, because otherwise we'll remove ourselves from the
-    // list of listeners while FocusManager is in the middle of iterating
-    // over that list.
-    MessageLoop::current()->PostTask(
-        FROM_HERE, method_factory_.NewRunnableMethod(
-            &ToolbarView::ExitMenuBarEmulationMode));
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, AccessibleToolbarView overrides:
 
@@ -413,43 +324,6 @@ void ToolbarView::ExecuteCommand(int command_id) {
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, views::View overrides:
 
-bool ToolbarView::AcceleratorPressed(
-    const views::Accelerator& accelerator) {
-  // The only accelerators we handle here are if the menus are focused.
-  views::View* focused_view = GetFocusManager()->GetFocusedView();
-  if (focused_view != page_menu_ && focused_view != app_menu_) {
-    ExitMenuBarEmulationMode();
-    return false;
-  }
-
-  // Safe to cast, given the check above.
-  views::MenuButton* menu = static_cast<views::MenuButton*>(focused_view);
-  switch (accelerator.GetKeyCode()) {
-    case base::VKEY_ESCAPE:
-      RestoreLastFocusedView();
-      return true;
-    case base::VKEY_LEFT:
-    case base::VKEY_RIGHT:
-      if (menu == app_menu_)
-        page_menu_->RequestFocus();
-      else
-        app_menu_->RequestFocus();
-      return true;
-    case base::VKEY_UP:
-    case base::VKEY_DOWN:
-    case base::VKEY_RETURN:
-    case base::VKEY_SPACE:
-      // Hide the tooltip before activating a menu button.
-      if (GetWidget()->GetTooltipManager())
-        GetWidget()->GetTooltipManager()->HideKeyboardTooltip();
-
-      ActivateMenuButton(menu);
-      return true;
-    default:
-      return false;
-  }
-}
-
 gfx::Size ToolbarView::GetPreferredSize() {
   if (IsDisplayModeNormal()) {
     int min_width = kControlIndent + back_->GetPreferredSize().width() +
@@ -835,99 +709,11 @@ void ToolbarView::LoadRightSideControlsImages() {
 void ToolbarView::RunPageMenu(const gfx::Point& pt) {
   page_menu_model_.reset(new PageMenuModel(this, browser_));
   page_menu_menu_.reset(new views::Menu2(page_menu_model_.get()));
-  for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
-    page_menu_menu_->AddMenuListener(menu_listeners_[i]);
-  }
   page_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
-  for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
-    page_menu_menu_->RemoveMenuListener(menu_listeners_[i]);
-  }
-  SwitchToOtherMenuIfNeeded(page_menu_menu_.get(), app_menu_);
 }
 
 void ToolbarView::RunAppMenu(const gfx::Point& pt) {
   if (app_menu_model_->BuildProfileSubMenu())
     app_menu_menu_->Rebuild();
-  for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
-    app_menu_menu_->AddMenuListener(menu_listeners_[i]);
-  }
   app_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
-  for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
-    app_menu_menu_->RemoveMenuListener(menu_listeners_[i]);
-  }
-  SwitchToOtherMenuIfNeeded(app_menu_menu_.get(), page_menu_);
-}
-
-void ToolbarView::SwitchToOtherMenuIfNeeded(
-    views::Menu2* previous_menu, views::MenuButton* next_menu_button) {
-  // If the user tried to move to the right or left, switch from the
-  // app menu to the page menu. Switching to the next menu is delayed
-  // until the next event loop so that the call stack that initiated
-  // activating the first menu can return. (If we didn't do this, the
-  // call stack would grow each time the user switches menus, and
-  // the actions taken after the user finally exits a menu would cause
-  // flicker.)
-  views::MenuWrapper::MenuAction action = previous_menu->GetMenuAction();
-  if (action == views::MenuWrapper::MENU_ACTION_NEXT ||
-      action == views::MenuWrapper::MENU_ACTION_PREVIOUS) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE, method_factory_.NewRunnableMethod(
-            &ToolbarView::ActivateMenuButton,
-            next_menu_button));
-  }
-}
-
-void ToolbarView::ActivateMenuButton(views::MenuButton* menu_button) {
-#if defined(OS_LINUX)
-  // Under GTK, opening a pop-up menu causes the main window to lose focus.
-  // Focus is automatically returned when the menu closes.
-  //
-  // Make sure that the menu button being activated has focus, so that
-  // when the user escapes from the menu without selecting anything, focus
-  // will be returned here.
-  if (!menu_button->HasFocus()) {
-    menu_button->RequestFocus();
-    GetFocusManager()->StoreFocusedView();
-  }
-#endif
-
-#if defined(OS_WIN)
-  // On Windows, we have to explicitly clear the focus before opening
-  // the pop-up menu, then set the focus again when it closes.
-  GetFocusManager()->ClearFocus();
-#endif
-
-  // Tell the menu button to activate, opening its pop-up menu.
-  menu_button->Activate();
-
-#if defined(OS_WIN)
-  EnterMenuBarEmulationMode(last_focused_view_storage_id_, menu_button);
-#endif
-}
-
-void ToolbarView::ExitMenuBarEmulationMode() {
-  if (page_menu_->HasFocus() || app_menu_->HasFocus())
-    RestoreLastFocusedView();
-
-  views::FocusManager* focus_manager = GetFocusManager();
-  focus_manager->UnregisterAccelerators(this);
-  focus_manager->RemoveFocusChangeListener(this);
-  page_menu_->SetFocusable(false);
-  app_menu_->SetFocusable(false);
-}
-
-void ToolbarView::RestoreLastFocusedView() {
-  views::ViewStorage* view_storage = views::ViewStorage::GetSharedInstance();
-  views::View* last_focused_view =
-      view_storage->RetrieveView(last_focused_view_storage_id_);
-  if (last_focused_view) {
-    last_focused_view->RequestFocus();
-  } else {
-    // Focus the location bar
-    views::View* view = GetAncestorWithClassName(BrowserView::kViewClassName);
-    if (view) {
-      BrowserView* browser_view = static_cast<BrowserView*>(view);
-      browser_view->SetFocusToLocationBar();
-    }
-  }
 }
diff --git a/chrome/browser/views/toolbar_view.h b/chrome/browser/views/toolbar_view.h
index 675eb33..23f5232 100644
--- a/chrome/browser/views/toolbar_view.h
+++ b/chrome/browser/views/toolbar_view.h
@@ -20,7 +20,6 @@
 #include "chrome/browser/views/location_bar_view.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/menu/menu.h"
-#include "views/controls/menu/menu_wrapper.h"
 #include "views/controls/menu/view_menu_delegate.h"
 #include "views/view.h"
 
@@ -37,7 +36,6 @@ class Menu2;
 class ToolbarView : public AccessibleToolbarView,
                     public views::ViewMenuDelegate,
                     public views::DragController,
-                    public views::FocusChangeListener,
                     public menus::SimpleMenuModel::Delegate,
                     public LocationBarView::Delegate,
                     public NotificationObserver,
@@ -46,7 +44,7 @@ class ToolbarView : public AccessibleToolbarView,
                     public BubblePositioner {
  public:
   explicit ToolbarView(Browser* browser);
-  virtual ~ToolbarView();
+  virtual ~ToolbarView() { }
 
   // Create the contents of the Browser Toolbar
   void Init(Profile* profile);
@@ -64,25 +62,6 @@ class ToolbarView : public AccessibleToolbarView,
   // Sets the app menu model.
   void SetAppMenuModel(AppMenuModel* model);
 
-  // Focuses the page menu and enters a special mode where the page
-  // and app menus are focusable and allow for keyboard navigation just
-  // like a normal menu bar. As soon as focus leaves one of the menus,
-  // the special mode is exited.
-  //
-  // Pass it the storage id of the view where focus should be returned
-  // if the user escapes, and the menu button to focus initially. If
-  // |menu_to_focus| is NULL, it will focus the page menu by default.
-  //
-  // Not used on the Mac, which has a "normal" menu bar.
-  void EnterMenuBarEmulationMode(int last_focused_view_storage_id,
-                                 views::MenuButton* menu_to_focus);
-
-  // Add a listener to receive a callback when the menu opens.
-  void AddMenuListener(views::MenuListener* listener);
-
-  // Remove a menu listener.
-  void RemoveMenuListener(views::MenuListener* listener);
-
   // Accessors...
   Browser* browser() const { return browser_; }
   BrowserActionsContainer* browser_actions() const { return browser_actions_; }
@@ -92,10 +71,6 @@ class ToolbarView : public AccessibleToolbarView,
   views::MenuButton* page_menu() const { return page_menu_; }
   views::MenuButton* app_menu() const { return app_menu_; }
 
-  // Overridden from views::FocusChangeListener:
-  virtual void FocusWillChange(views::View* focused_before,
-                               views::View* focused_now);
-
   // Overridden from AccessibleToolbarView:
   virtual bool IsAccessibleViewTraversable(views::View* view);
 
@@ -131,7 +106,6 @@ class ToolbarView : public AccessibleToolbarView,
   virtual void ExecuteCommand(int command_id);
 
   // Overridden from views::View:
-  virtual bool AcceleratorPressed(const views::Accelerator& accelerator);
   virtual gfx::Size GetPreferredSize();
   virtual void Layout();
   virtual void Paint(gfx::Canvas* canvas);
@@ -164,13 +138,6 @@ class ToolbarView : public AccessibleToolbarView,
   void RunPageMenu(const gfx::Point& pt);
   void RunAppMenu(const gfx::Point& pt);
 
-  // Check if the menu exited with a code indicating the user wants to
-  // switch to the other menu, and then switch to that other menu.
-  void SwitchToOtherMenuIfNeeded(views::Menu2* previous_menu,
-                                 views::MenuButton* next_menu_button);
-
-  void ActivateMenuButton(views::MenuButton* menu_button);
-
   // Types of display mode this toolbar can have.
   enum DisplayMode {
     DISPLAYMODE_NORMAL,       // Normal toolbar with buttons, etc.
@@ -181,14 +148,6 @@ class ToolbarView : public AccessibleToolbarView,
     return display_mode_ == DISPLAYMODE_NORMAL;
   }
 
-  // Take the menus out of the focus traversal, unregister accelerators,
-  // and stop listening to focus change events.
-  void ExitMenuBarEmulationMode();
-
-  // Restore the view that was focused before EnterMenuBarEmulationMode
-  // was called.
-  void RestoreLastFocusedView();
-
   scoped_ptr<BackForwardMenuModel> back_menu_model_;
   scoped_ptr<BackForwardMenuModel> forward_menu_model_;
 
@@ -227,16 +186,6 @@ class ToolbarView : public AccessibleToolbarView,
   // TODO(beng): build these into MenuButton.
   scoped_ptr<views::Menu2> page_menu_menu_;
   scoped_ptr<views::Menu2> app_menu_menu_;
-
-  // Storage id for the last view that was focused before focus
-  // was given to one of the toolbar views.
-  int last_focused_view_storage_id_;
-
-  // Vector of listeners to receive callbacks when the menu opens.
-  std::vector<views::MenuListener*> menu_listeners_;
-
-  // Used to post tasks to switch to the next/previous menu.
-  ScopedRunnableMethodFactory<ToolbarView> method_factory_;
 };
 
 #endif  // CHROME_BROWSER_VIEWS_TOOLBAR_VIEW_H_