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

chrome/browser/ui/browser.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_BROWSER_H_
 #define CHROME_BROWSER_UI_BROWSER_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
-#include "chrome/browser/command_updater.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/event_disposition.h"
 #include "chrome/browser/extensions/extension_tab_helper_delegate.h"
 #include "chrome/browser/instant/instant_delegate.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/sessions/session_id.h"
-#include "chrome/browser/sessions/tab_restore_service_observer.h"
-#include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper_delegate.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/constrained_window_tab_helper_delegate.h"
 #include "chrome/browser/ui/fullscreen_exit_bubble_type.h"
 #include "chrome/browser/ui/search_engines/search_engine_tab_helper_delegate.h"
 #include "chrome/browser/ui/select_file_dialog.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
@@ skipping 23 matching lines @@
 class InstantUnloadHandler;
 class PrefService;
 class Profile;
 class SkBitmap;
 class StatusBubble;
 class TabNavigation;
 class TabStripModel;
 struct WebApplicationInfo;
 
 namespace chrome {
+class BrowserCommandController;
 namespace search {
 class SearchDelegate;
 class SearchModel;
 }
 }
 
 namespace content {
 class NavigationController;
 class SessionStorageNamespace;
 }
@@ skipping 18 matching lines @@
                 public TabStripModelObserver,
                 public content::WebContentsDelegate,
                 public CoreTabHelperDelegate,
                 public SearchEngineTabHelperDelegate,
                 public ConstrainedWindowTabHelperDelegate,
                 public BlockedContentTabHelperDelegate,
                 public BookmarkTabHelperDelegate,
                 public ZoomObserver,
                 public ExtensionTabHelperDelegate,
                 public content::PageNavigator,
-                public CommandUpdater::CommandUpdaterDelegate,
                 public content::NotificationObserver,
                 public SelectFileDialog::Listener,
-                public TabRestoreServiceObserver,
-                public ProfileSyncServiceObserver,
                 public InstantDelegate {
  public:
   // SessionService::WindowType mirrors these values.  If you add to this
   // enum, look at SessionService::WindowType to see if it needs to be
   // updated.
   enum Type {
     // If you add a new type, consider updating the test
     // BrowserTest.StartMaximized.
     TYPE_TABBED = 1,
     TYPE_POPUP = 2,
@@ skipping 138 matching lines @@
   gfx::Rect override_bounds() const { return override_bounds_; }
 
   // Returns the InstantController or NULL if there is no InstantController for
   // this Browser.
   InstantController* instant() const { return instant_.get(); }
 
   // |window()| will return NULL if called before |CreateBrowserWindow()|
   // is done.
   BrowserWindow* window() const { return window_; }
   ToolbarModel* toolbar_model() { return toolbar_model_.get(); }
+  const ToolbarModel* toolbar_model() const { return toolbar_model_.get(); }
+  chrome::BrowserCommandController* command_controller() {
+    return command_controller_.get();
+  }
   chrome::search::SearchModel* search_model() { return search_model_.get(); }
   const SessionID& session_id() const { return session_id_; }
-  CommandUpdater* command_updater() { return &command_updater_; }
-  bool block_command_execution() const { return block_command_execution_; }
   BrowserContentSettingBubbleModelDelegate*
       content_setting_bubble_model_delegate() {
     return content_setting_bubble_model_delegate_.get();
   }
   BrowserTabRestoreServiceDelegate* tab_restore_service_delegate() {
     return tab_restore_service_delegate_.get();
   }
   BrowserSyncedWindowDelegate* synced_window_delegate() {
     return synced_window_delegate_.get();
   }
@@ skipping 206 matching lines @@
       bool user_gesture);
 
   // Helper function to handle find results.
   static void FindReplyHelper(content::WebContents* web_contents,
                               int request_id,
                               int number_of_matches,
                               const gfx::Rect& selection_rect,
                               int active_match_ordinal,
                               bool final_update);
 
-  // Calls ExecuteCommandWithDisposition with CURRENT_TAB disposition.
-  void ExecuteCommand(int id);
-
-  // Calls ExecuteCommandWithDisposition with the given event flags.
-  void ExecuteCommand(int id, int event_flags);
-
-  // Executes a command if it's enabled.
-  // Returns true if the command is executed.
-  bool ExecuteCommandIfEnabled(int id);
-
-  // Returns true if |command_id| is a reserved command whose keyboard shortcuts
-  // should not be sent to the renderer or |event| was triggered by a key that
-  // we never want to send to the renderer.
-  bool IsReservedCommandOrKey(int command_id,
-                              const content::NativeWebKeyboardEvent& event);
-
-  // Sets if command execution shall be blocked. If |block| is true then
-  // following calls to ExecuteCommand() or ExecuteCommandWithDisposition()
-  // method will not execute the command, and the last blocked command will be
-  // recorded for retrieval.
-  void SetBlockCommandExecution(bool block);
-
-  // Gets the last blocked command after calling SetBlockCommandExecution(true).
-  // Returns the command id or -1 if there is no command blocked. The
-  // disposition type of the command will be stored in |*disposition| if it's
-  // not null.
-  int GetLastBlockedCommand(WindowOpenDisposition* disposition);
-
   // Called by browser::Navigate() when a navigation has occurred in a tab in
   // this Browser. Updates the UI for the start of this navigation.
   void UpdateUIForNavigationInTab(TabContents* contents,
                                   content::PageTransition transition,
                                   bool user_initiated);
 
   // Interface implementations ////////////////////////////////////////////////
 
   // Overridden from content::PageNavigator:
   virtual content::WebContents* OpenURL(
       const content::OpenURLParams& params) OVERRIDE;
 
-  // Overridden from CommandUpdater::CommandUpdaterDelegate:
-  virtual void ExecuteCommandWithDisposition(
-      int id,
-      WindowOpenDisposition disposition) OVERRIDE;
-
-  // Overridden from TabRestoreServiceObserver:
-  virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE;
-  virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE;
-
   // Centralized method for creating a TabContents, configuring and
   // installing all its supporting objects and observers.
   static TabContents* TabContentsFactory(
       Profile* profile,
       content::SiteInstance* site_instance,
       int routing_id,
       const content::WebContents* base_web_contents,
       content::SessionStorageNamespace* session_storage_namespace);
 
   // Overridden from TabStripModelDelegate:
@@ skipping 139 matching lines @@
     // Change is the result of the bookmark bar pref changing.
     BOOKMARK_BAR_STATE_CHANGE_PREF_CHANGE,
 
     // Change is the result of a state change in the active tab.
     BOOKMARK_BAR_STATE_CHANGE_TAB_STATE,
 
     // Change is the result of window toggling in/out of fullscreen mode.
     BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN,
   };
 
-  enum FullScreenMode {
-    // Not in fullscreen mode.
-    FULLSCREEN_DISABLED,
-
-    // Fullscreen mode, occupying the whole screen.
-    FULLSCREEN_NORMAL,
-
-    // Fullscreen mode for metro snap, occupying the full height and 20% of
-    // the screen width.
-    FULLSCREEN_METRO_SNAP,
-  };
-
   // Overridden from content::WebContentsDelegate:
   virtual content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) OVERRIDE;
   virtual void NavigationStateChanged(const content::WebContents* source,
                                       unsigned changed_flags) OVERRIDE;
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
@@ skipping 145 matching lines @@
   // Overridden from SelectFileDialog::Listener:
   virtual void FileSelected(const FilePath& path,
                             int index,
                             void* params) OVERRIDE;
 
   // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  // Overridden from ProfileSyncServiceObserver:
-  virtual void OnStateChanged() OVERRIDE;
-
   // Overriden from InstantDelegate:
   virtual void ShowInstant(TabContents* preview_contents) OVERRIDE;
   virtual void HideInstant() OVERRIDE;
   virtual void CommitInstant(TabContents* preview_contents) OVERRIDE;
   virtual void SetSuggestedText(const string16& text,
                                 InstantCompleteBehavior behavior) OVERRIDE;
   virtual gfx::Rect GetInstantBounds() OVERRIDE;
   virtual void InstantPreviewFocused() OVERRIDE;
   virtual TabContents* GetInstantHostTabContents() const OVERRIDE;
 
   // Command and state updating ///////////////////////////////////////////////
 
-  // Returns true if the regular Chrome UI (not the fullscreen one and
-  // not the single-tab one) is shown. Used for updating window command states
-  // only. Consider using SupportsWindowFeature if you need the mentioned
-  // functionality anywhere else.
-  bool IsShowingMainUI(bool is_fullscreen);
-
-  // Initialize state for all browser commands.
-  void InitCommandState();
-
-  // Update commands whose state depends on incognito mode availability.
-  void UpdateCommandsForIncognitoAvailability();
-
-  // Update commands whose state depends on the tab's state.
-  void UpdateCommandsForTabState();
-
-  // Updates commands when the content's restrictions change.
-  void UpdateCommandsForContentRestrictionState();
-
-  // Updates commands for enabling developer tools.
-  void UpdateCommandsForDevTools();
-
-  // Updates commands for bookmark editing.
-  void UpdateCommandsForBookmarkEditing();
-
-  // Updates commands that affect the bookmark bar.
-  void UpdateCommandsForBookmarkBar();
-
   // Set the preference that indicates that the home page has been changed.
   void MarkHomePageAsChanged(PrefService* pref_service);
 
-  // Update commands whose state depends on the type of fullscreen mode the
-  // window is in.
-  void UpdateCommandsForFullscreenMode(FullScreenMode fullscreen_mode);
-
-  // Update commands whose state depends on whether multiple profiles are
-  // allowed.
-  void UpdateCommandsForMultipleProfiles();
-
-  // Updates the printing command state.
-  void UpdatePrintingState(int content_restrictions);
-
-  // Updates the save-page-as command state.
-  void UpdateSaveAsState(int content_restrictions);
-
-  // Updates the open-file state (Mac Only).
-  void UpdateOpenFileState();
-
-  // Ask the Reload/Stop button to change its icon, and update the Stop command
-  // state.  |is_loading| is true if the current WebContents is loading.
-  // |force| is true if the button should change its icon immediately.
-  void UpdateReloadStopState(bool is_loading, bool force);
-
   // UI update coalescing and handling ////////////////////////////////////////
 
   // Asks the toolbar (and as such the location bar) to update its state to
   // reflect the current tab's current URL, security state, etc.
   // If |should_restore_state| is true, we're switching (back?) to this tab and
   // should restore any previous location bar state (such as user editing) as
   // well.
   void UpdateToolbar(bool should_restore_state);
 
   // Updates the browser's search model with the tab's search model.
@@ skipping 101 matching lines @@
   // Implementation of SupportsWindowFeature and CanSupportWindowFeature. If
   // |check_fullscreen| is true, the set of features reflect the actual state of
   // the browser, otherwise the set of features reflect the possible state of
   // the browser.
   bool SupportsWindowFeatureImpl(WindowFeature feature,
                                  bool check_fullscreen) const;
 
   // If this browser should have instant one is created, otherwise does nothing.
   void CreateInstantIfNecessary();
 
-  // Retrieves the content restrictions for the currently selected tab.
-  // Returns 0 if no tab selected, which is equivalent to no content
-  // restrictions active.
-  int GetContentRestrictionsForSelectedTab();
-
   // Resets |bookmark_bar_state_| based on the active tab. Notifies the
   // BrowserWindow if necessary.
   void UpdateBookmarkBarState(BookmarkBarStateChangeReason reason);
 
   // Creates a BackgroundContents if appropriate; return true if one was
   // created.
   bool MaybeCreateBackgroundContents(int route_id,
                                      content::WebContents* opener_web_contents,
                                      const string16& frame_name,
                                      const GURL& target_url);
 
   // Data members /////////////////////////////////////////////////////////////
 
   content::NotificationRegistrar registrar_;
 
   PrefChangeRegistrar profile_pref_registrar_;
 
-  PrefChangeRegistrar local_pref_registrar_;
-
   // This Browser's type.
   const Type type_;
 
   // This Browser's profile.
   Profile* const profile_;
 
   // This Browser's window.
   BrowserWindow* window_;
 
   scoped_ptr<TabStripModel> tab_strip_model_;
 
-  // The CommandUpdater that manages the browser window commands.
-  CommandUpdater command_updater_;
-
   // The application name that is also the name of the window to the shell.
   // This name should be set when:
   // 1) we launch an application via an application shortcut or extension API.
   // 2) we launch an undocked devtool window.
   std::string app_name_;
 
   // Type of app (host or child). See description of AppType.
   AppType app_type_;
 
   // Unique identifier of this browser for session restore. This id is only
@@ skipping 71 matching lines @@
   // The Find Bar. This may be NULL if there is no Find Bar, and if it is
   // non-NULL, it may or may not be visible.
   scoped_ptr<FindBarController> find_bar_controller_;
 
   // Dialog box used for opening and saving files.
   scoped_refptr<SelectFileDialog> select_file_dialog_;
 
   // Keep track of the encoding auto detect pref.
   BooleanPrefMember encoding_auto_detect_;
 
-  // Indicates if command execution is blocked.
-  bool block_command_execution_;
-
-  // Stores the last blocked command id when |block_command_execution_| is true.
-  int last_blocked_command_id_;
-
-  // Stores the disposition type of the last blocked command.
-  WindowOpenDisposition last_blocked_command_disposition_;
-
   // Which deferred action to perform when OnDidGetApplicationInfo is notified
   // from a WebContents. Currently, only one pending action is allowed.
   WebAppAction pending_web_app_action_;
 
-  // The profile's tab restore service. The service is owned by the profile,
-  // and we install ourselves as an observer.
-  TabRestoreService* tab_restore_service_;
-
   // Helper which implements the ContentSettingBubbleModel interface.
   scoped_ptr<BrowserContentSettingBubbleModelDelegate>
       content_setting_bubble_model_delegate_;
 
   // Helper which implements the ToolbarModelDelegate interface.
   scoped_ptr<BrowserToolbarModelDelegate> toolbar_model_delegate_;
 
   // A delegate that handles the details of updating the "active"
   // |search_model_| state with the tab's state.
   scoped_ptr<chrome::search::SearchDelegate> search_delegate_;
 
   // Helper which implements the TabRestoreServiceDelegate interface.
   scoped_ptr<BrowserTabRestoreServiceDelegate> tab_restore_service_delegate_;
 
   // Helper which implements the SyncedWindowDelegate interface.
   scoped_ptr<BrowserSyncedWindowDelegate> synced_window_delegate_;
 
   scoped_ptr<InstantController> instant_;
   scoped_ptr<InstantUnloadHandler> instant_unload_handler_;
 
   BookmarkBar::State bookmark_bar_state_;
 
   scoped_refptr<FullscreenController> fullscreen_controller_;
 
   scoped_ptr<ExtensionWindowController> extension_window_controller_;
 
+  scoped_ptr<chrome::BrowserCommandController> command_controller_;
+
   // True if the browser window has been shown at least once.
   bool window_has_shown_;
 
   // Currently open color chooser. Non-NULL after OpenColorChooser is called and
   // before DidEndColorChooser is called.
   scoped_ptr<content::ColorChooser> color_chooser_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_