Move command handling and updating off Browser and onto a helper object.

chrome/browser/ui/gtk/browser_window_gtk.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 
 #include <dlfcn.h>
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
@@ skipping 19 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/gtk/accelerators_gtk.h"
 #include "chrome/browser/ui/gtk/avatar_menu_bubble_gtk.h"
 #include "chrome/browser/ui/gtk/avatar_menu_button_gtk.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_bar_gtk.h"
@@ skipping 1122 matching lines @@
     // |browser_| object.
     //
     // Pros of this approach:
     // 1. We don't need to care about keyboard layout problem, as
     //    gtk_window_activate_key() method handles it for us.
     //
     // Cons:
     // 1. The logic is a little complicated.
     // 2. We should be careful not to introduce any accelerators that trigger
     //    customized code instead of browser commands.
-    browser_->SetBlockCommandExecution(true);
+    browser_->command_controller()->SetBlockCommandExecution(true);
     gtk_window_activate_key(window_, os_event);
     // We don't need to care about the WindowOpenDisposition value,
     // because all commands executed in this path use the default value.
-    id = browser_->GetLastBlockedCommand(NULL);
-    browser_->SetBlockCommandExecution(false);
+    id = browser_->command_controller()->GetLastBlockedCommand(NULL);
+    browser_->command_controller()->SetBlockCommandExecution(false);
   }
 
   if (id == -1)
     return false;
 
   // Executing the command may cause |this| object to be destroyed.
-  if (browser_->IsReservedCommandOrKey(id, event) && !event.match_edit_command)
-    return browser_->ExecuteCommandIfEnabled(id);
+  if (browser_->command_controller()->IsReservedCommandOrKey(id, event) &&
+      !event.match_edit_command) {
+    return chrome::ExecuteCommand(browser_.get(), id);
+  }
 
   // The |event| is a keyboard shortcut.
   DCHECK(is_keyboard_shortcut != NULL);
   *is_keyboard_shortcut = true;
 
   return false;
 }
 
 void BrowserWindowGtk::HandleKeyboardEvent(
     const NativeWebKeyboardEvent& event) {
   GdkEventKey* os_event = &event.os_event->key;
 
   if (!os_event || event.type != WebKit::WebInputEvent::RawKeyDown)
     return;
 
   // Handles a key event in following sequence:
   // 1. Our special key accelerators, such as ctrl-tab, etc.
   // 2. Gtk accelerators.
   // This sequence matches the default key press handler of GtkWindow.
   //
   // It's not necessary to care about the keyboard layout, as
   // gtk_window_activate_key() takes care of it automatically.
   int id = GetCustomCommandId(os_event);
   if (id != -1)
-    browser_->ExecuteCommandIfEnabled(id);
+    chrome::ExecuteCommand(browser_.get(), id);
   else
     gtk_window_activate_key(window_, os_event);
 }
 
 void BrowserWindowGtk::ShowCreateWebAppShortcutsDialog(
     TabContents* tab_contents) {
   CreateWebApplicationShortcutsDialogGtk::Show(window_, tab_contents);
 }
 
 void BrowserWindowGtk::ShowCreateChromeAppShortcutsDialog(
@@ skipping 967 matching lines @@
 // static
 gboolean BrowserWindowGtk::OnGtkAccelerator(GtkAccelGroup* accel_group,
                                             GObject* acceleratable,
                                             guint keyval,
                                             GdkModifierType modifier,
                                             void* user_data) {
   int command_id = GPOINTER_TO_INT(user_data);
   BrowserWindowGtk* browser_window =
       GetBrowserWindowForNativeWindow(GTK_WINDOW(acceleratable));
   DCHECK(browser_window != NULL);
-  return browser_window->browser()->ExecuteCommandIfEnabled(command_id);
+  return chrome::ExecuteCommand(browser_window->browser(), command_id);
 }
 
 // Let the focused widget have first crack at the key event so we don't
 // override their accelerators, except if there is a priority keybinding
 // handler registered (it should take precedence).
 gboolean BrowserWindowGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
   if (extension_keybinding_registry_->HasPriorityHandler(event))
     return FALSE;
 
   // If a widget besides the native view is focused, we have to try to handle
   // the custom accelerators before letting it handle them.
   WebContents* current_web_contents =
       browser()->GetActiveWebContents();
   // The current tab might not have a render view if it crashed.
   if (!current_web_contents || !current_web_contents->GetContentNativeView() ||
       !gtk_widget_is_focus(current_web_contents->GetContentNativeView())) {
     int command_id = GetCustomCommandId(event);
     if (command_id == -1)
       command_id = GetPreHandleCommandId(event);
 
-    if (command_id != -1 && browser_->ExecuteCommandIfEnabled(command_id))
+    if (command_id != -1 && chrome::ExecuteCommand(browser_.get(), command_id))
       return TRUE;
 
     // Propagate the key event to child widget first, so we don't override their
     // accelerators.
     if (!gtk_window_propagate_key_event(GTK_WINDOW(widget), event)) {
       if (!gtk_window_activate_key(GTK_WINDOW(widget), event)) {
         gtk_bindings_activate_event(GTK_OBJECT(widget), event);
       }
     }
   } else {
@@ skipping 360 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }