Revert "Keyboard accessibility for the page and app menus.", rev 42234 and 42236.

TBR=dmazzoni

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

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

19 files changed, 34 insertions, 436 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index d8bfa76..a2b7d8d 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -86,11 +86,6 @@
 #include "chrome/browser/automation/ui_controls.h"
 #endif  // !defined(OS_MACOSX)
 
-#if defined(TOOLKIT_VIEWS)
-#include "views/focus/focus_manager.h"
-#include "views/view.h"
-#endif  // defined(TOOLKIT_VIEWS)
-
 using base::Time;
 
 class AutomationInterstitialPage : public InterstitialPage {
@@ -350,11 +345,7 @@ void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(AutomationMsg_ConstrainedWindowCount,
                         GetConstrainedWindowCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_FindInPage, HandleFindInPageRequest)
-#if defined(TOOLKIT_VIEWS)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetFocusedViewID, GetFocusedViewID)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForFocusedViewIDToChange,
-                                    WaitForFocusedViewIDToChange)
-#endif
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_InspectElement,
                                     HandleInspectElementRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_DownloadDirectory, GetDownloadDirectory)
@@ -506,7 +497,6 @@ void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_LoginWithUserAndPass,
                                     LoginWithUserAndPass)
 #endif
-    IPC_MESSAGE_HANDLER(AutomationMsg_IsPopUpMenuOpen, IsPopUpMenuOpen)
   IPC_END_MESSAGE_MAP()
 }
 
@@ -2538,99 +2528,3 @@ void AutomationProvider::SetContentSetting(
     *success = true;
   }
 }
-
-#if defined(TOOLKIT_VIEWS)
-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);
-}
-#else
-void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
-  NOTIMPLEMENTED();
-};
-
-void AutomationProvider::WaitForFocusedViewIDToChange(
-    int handle, int previous_view_id, 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 29aba68..e5b36bf 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -247,9 +247,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
 #endif  // defined(OS_WIN)
 
   void GetFocusedViewID(int handle, int* view_id);
-  void WaitForFocusedViewIDToChange(int handle,
-                                    int previous_view_id,
-                                    IPC::Message* reply_message);
 
   // Helper function to find the browser window that contains a given
   // NavigationController and activate that tab.
@@ -582,10 +579,6 @@ class AutomationProvider : public base::RefCounted<AutomationProvider>,
   // Returns NULL on failure.
   RenderViewHost* GetViewForTab(int tab_handle);
 
-  // Returns true if any popup menu is open. Currently only fully implemented
-  // on Windows and doesn't support bookmark menus.
-  void IsPopUpMenuOpen(int handle, bool* success, bool* is_open);
-
   typedef ObserverList<NotificationObserver> NotificationObserverList;
   typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
   typedef std::map<int, ExtensionPortContainer*> PortContainerMap;
diff --git a/chrome/browser/automation/automation_provider_gtk.cc b/chrome/browser/automation/automation_provider_gtk.cc
index c617f3f..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();
 }
@@ -224,11 +228,3 @@ void AutomationProvider::GetWindowTitle(int handle, string16* text) {
   text->assign(UTF8ToUTF16(title));
 }
 
-void AutomationProvider::IsPopUpMenuOpen(
-    int handle, bool* success, bool* is_open) {
-  *success = true;
-  *is_open = true;
-  // A GTK implementation of this method is not currently needed; GTK menus
-  // pop up immediately so there's no need to wait until they appear.
-  NOTIMPLEMENTED();
-}
diff --git a/chrome/browser/automation/automation_provider_mac.mm b/chrome/browser/automation/automation_provider_mac.mm
index 08a9575..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();
 }
@@ -155,9 +159,3 @@ void AutomationProvider::GetWindowTitle(int handle, string16* text) {
   text->assign(base::SysNSStringToUTF16(title));
 }
 
-void AutomationProvider::IsPopUpMenuOpen(
-    int handle, bool* success, bool* is_open) {
-  *success = false;
-  *is_open = false;
-  NOTIMPLEMENTED();
-}
diff --git a/chrome/browser/automation/automation_provider_views.cc b/chrome/browser/automation/automation_provider_views.cc
index a827b06..f161105 100644
--- a/chrome/browser/automation/automation_provider_views.cc
+++ b/chrome/browser/automation/automation_provider_views.cc
@@ -33,3 +33,4 @@ void AutomationProvider::WindowGetViewBounds(int handle, int view_id,
     }
   }
 }
+
diff --git a/chrome/browser/automation/automation_provider_win.cc b/chrome/browser/automation/automation_provider_win.cc
index 9474e90..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;
@@ -493,13 +506,3 @@ void AutomationProvider::GetWindowTitle(int handle, string16* text) {
   ::GetWindowText(window, WriteInto(&result, length), length);
   text->assign(WideToUTF16(result));
 }
-
-void AutomationProvider::IsPopUpMenuOpen(
-    int handle, bool* success, bool* is_open) {
-  *success = true;
-
-  // Check for the existence of a pop-up menu using its
-  // window class (#32768). Note that this won't cover
-  // bookmark menus.
-  *is_open = (::FindWindow(L"#32768", 0) != NULL);
-}
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 3ddc3a8..f2779af 100644
--- a/chrome/browser/browser.cc
+++ b/chrome/browser/browser.cc
@@ -873,9 +873,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);
@@ -1309,11 +1306,6 @@ void Browser::FocusToolbar() {
   window_->FocusToolbar();
 }
 
-void Browser::FocusPageAndAppMenus() {
-  UserMetrics::RecordAction("EnterMenuBarEmulationMode", profile_);
-  window_->FocusPageAndAppMenus();
-}
-
 void Browser::FocusLocationBar() {
   UserMetrics::RecordAction("FocusLocation", profile_);
   window_->SetFocusToLocationBar();
@@ -1737,7 +1729,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 c2e3911..a4ff572 100644
--- a/chrome/browser/browser_window.h
+++ b/chrome/browser/browser_window.h
@@ -150,11 +150,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 4de884a..b0ace80 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 83706d7..01d592e 100644
--- a/chrome/browser/cocoa/browser_window_cocoa.mm
+++ b/chrome/browser/cocoa/browser_window_cocoa.mm
@@ -237,10 +237,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 fa63d58..e0d60adf 100644
--- a/chrome/browser/gtk/browser_window_gtk.cc
+++ b/chrome/browser/gtk/browser_window_gtk.cc
@@ -783,10 +783,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 67613b6..f24e094 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 328b954..d484765 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_);
   }
 }
 
@@ -863,31 +863,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 026fa53..bf753e9 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 0153012..9670c24 100644
--- a/chrome/browser/views/toolbar_view.cc
+++ b/chrome/browser/views/toolbar_view.cc
@@ -35,7 +35,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,66 +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);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 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:
 
@@ -397,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() +
@@ -819,86 +709,10 @@ 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()));
   page_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
-  SwitchToOtherMenuIfNeeded(page_menu_menu_.get(), app_menu_);
 }
 
 void ToolbarView::RunAppMenu(const gfx::Point& pt) {
   if (app_menu_model_->BuildProfileSubMenu())
     app_menu_menu_->Rebuild();
   app_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
-  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 9425b56..23f5232 100644
--- a/chrome/browser/views/toolbar_view.h
+++ b/chrome/browser/views/toolbar_view.h
@@ -36,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,
@@ -45,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);
@@ -63,19 +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);
-
   // Accessors...
   Browser* browser() const { return browser_; }
   BrowserActionsContainer* browser_actions() const { return browser_actions_; }
@@ -85,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);
 
@@ -124,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);
@@ -157,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.
@@ -174,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_;
 
@@ -220,13 +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_;
-
-  // Used to post tasks to switch to the next/previous menu.
-  ScopedRunnableMethodFactory<ToolbarView> method_factory_;
 };
 
 #endif  // CHROME_BROWSER_VIEWS_TOOLBAR_VIEW_H_