Decouple TabRestoreService from Browser

chrome/browser/ui/browser.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef 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/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/task.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/instant/instant_delegate.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/sessions/session_id.h"
+#include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_observer.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/tabs/tab_handler.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"  // TODO(beng): remove
 #include "chrome/browser/tabs/tab_strip_model_observer.h"  // TODO(beng): remove
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/search_engines/search_engine_tab_helper_delegate.h"
 #include "chrome/browser/ui/shell_dialogs.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_model.h"
@@ skipping 23 matching lines @@
 }
 
 class Browser : public TabHandlerDelegate,
                 public TabContentsDelegate,
                 public TabContentsWrapperDelegate,
                 public SearchEngineTabHelperDelegate,
                 public PageNavigator,
                 public CommandUpdater::CommandUpdaterDelegate,
                 public NotificationObserver,
                 public SelectFileDialog::Listener,
+                public TabRestoreServiceDelegate,
                 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 {
     TYPE_NORMAL = 1,
     TYPE_POPUP = 2,
@@ skipping 91 matching lines @@
   }
 
   // Creates the Browser Window. Prefer to use the static helpers above where
   // possible. This does not show the window. You need to call window()->Show()
   // to show it.
   void CreateBrowserWindow();
 
   // Accessors ////////////////////////////////////////////////////////////////
 
   Type type() const { return type_; }
+  virtual bool IsNormalBrowser() const { return type_ == TYPE_NORMAL; }
   const std::string& app_name() const { return app_name_; }
-  Profile* profile() const { return profile_; }
+  virtual Profile* profile() const { return profile_; }
   const std::vector<std::wstring>& user_data_dir_profiles() const;
 
   // Returns the InstantController or NULL if there is no InstantController for
   // this Browser.
   InstantController* instant() const { return instant_.get(); }
 
 #if defined(UNIT_TEST)
   // Sets the BrowserWindow. This is intended for testing and generally not
   // useful outside of testing. Use CreateBrowserWindow outside of testing, or
   // the static convenience methods that create a BrowserWindow for you.
   void set_window(BrowserWindow* window) {
     DCHECK(!window_);
     window_ = window;
   }
 #endif
 
   // |window()| will return NULL if called before |CreateBrowserWindow()|
   // is done.
-  BrowserWindow* window() const { return window_; }
+  virtual BrowserWindow* window() const { return window_; }
   ToolbarModel* toolbar_model() { return &toolbar_model_; }
-  const SessionID& session_id() const { return session_id_; }
+  virtual const SessionID& session_id() const { return session_id_; }
   CommandUpdater* command_updater() { return &command_updater_; }
   bool block_command_execution() const { return block_command_execution_; }
 
   // Get the FindBarController for this browser, creating it if it does not
   // yet exist.
   FindBarController* GetFindBarController();
 
   // Returns true if a FindBarController exists for this browser.
   bool HasFindBarController() const;
 
@@ skipping 115 matching lines @@
   // downloads running.
   void InProgressDownloadResponse(bool cancel_downloads);
 
   // TabStripModel pass-thrus /////////////////////////////////////////////////
 
   TabStripModel* tabstrip_model() const {
     // TODO(beng): remove this accessor. It violates google style.
     return tab_handler_->GetTabStripModel();
   }
 
-  int tab_count() const;
-  int selected_index() const;
-  int GetIndexOfController(const NavigationController* controller) const;
+  virtual int tab_count() const;
+  virtual int selected_index() const;
+  virtual int GetIndexOfController(
+      const NavigationController* controller) const;
   TabContentsWrapper* GetSelectedTabContentsWrapper() const;
   TabContentsWrapper* GetTabContentsWrapperAt(int index) const;
   // Same as above but correctly handles if GetSelectedTabContents() is NULL
   // in the model before dereferencing to get the raw TabContents.
   // TODO(pinkerton): These should really be returning TabContentsWrapper
   // objects, but that would require changing about 50+ other files. In order
   // to keep changes localized, the default is to return a TabContents. Note
   // this differs from the TabStripModel because it has far fewer clients.
-  TabContents* GetSelectedTabContents() const;
-  TabContents* GetTabContentsAt(int index) const;
+  virtual TabContents* GetSelectedTabContents() const;
+  virtual TabContents* GetTabContentsAt(int index) const;
   void SelectTabContentsAt(int index, bool user_gesture);
+  virtual bool IsTabPinned(int index) const;
   void CloseAllTabs();
 
   // Tab adding/showing functions /////////////////////////////////////////////
 
   // Returns true if the tab strip is editable (for extensions).
   bool IsTabStripEditable() const;
 
   // Returns the index to insert a tab at during session restore and startup.
   // |relative_index| gives the index of the url into the number of tabs that
   // are going to be opened. For example, if three urls are passed in on the
@@ skipping 12 matching lines @@
                       PageTransition::Type type);
 
   // Add a tab with its session history restored from the SessionRestore
   // system. If select is true, the tab is selected. |tab_index| gives the index
   // to insert the tab at. |selected_navigation| is the index of the
   // TabNavigation in |navigations| to select. If |extension_app_id| is
   // non-empty the tab is an app tab and |extension_app_id| is the id of the
   // extension. If |pin| is true and |tab_index|/ is the last pinned tab, then
   // the newly created tab is pinned. If |from_last_session| is true,
   // |navigations| are from the previous session.
-  TabContents* AddRestoredTab(const std::vector<TabNavigation>& navigations,
-                              int tab_index,
-                              int selected_navigation,
-                              const std::string& extension_app_id,
-                              bool select,
-                              bool pin,
-                              bool from_last_session,
-                              SessionStorageNamespace* storage_namespace);
+  virtual TabContents* AddRestoredTab(

[Ben Goodger (Google), 2011/03/10 18:28:35]

In Chrome code we tend to put all the overrides from a particular base together.
We also remove all the comments, since the method is documented in the interface
or base class.

e.g.

// Overridden from SomeInterface:
virtual void Foo() OVERRIDE;
virtual int GetBar() const OVERRIDE;
virtual void StartBaz(int goat) OVERRIDE;

+      const std::vector<TabNavigation>& navigations,
+      int tab_index,
+      int selected_navigation,
+      const std::string& extension_app_id,
+      bool select,
+      bool pin,
+      bool from_last_session,
+      SessionStorageNamespace* storage_namespace);
   // Creates a new tab with the already-created TabContents 'new_contents'.
   // The window for the added contents will be reparented correctly when this
   // method returns.  If |disposition| is NEW_POPUP, |pos| should hold the
   // initial position.
   void AddTabContents(TabContents* new_contents,
                       WindowOpenDisposition disposition,
                       const gfx::Rect& initial_pos,
                       bool user_gesture);
   void CloseTabContents(TabContents* contents);
 
   // Show a dialog with HTML content. |delegate| contains a pointer to the
   // delegate who knows how to display the dialog (which file URL and JSON
   // string input to use during initialization). |parent_window| is the window
   // that should be parent of the dialog, or NULL for the default.
   void BrowserShowHtmlDialog(HtmlDialogUIDelegate* delegate,
                              gfx::NativeWindow parent_window);
 
   // Called when a popup select is about to be displayed.
   void BrowserRenderWidgetShowing();
 
   // Notification that some of our content has changed size as
   // part of an animation.
   void ToolbarSizeChanged(bool is_animating);
 
   // Replaces the state of the currently selected tab with the session
   // history restored from the SessionRestore system.
-  void ReplaceRestoredTab(
+  virtual void ReplaceRestoredTab(
       const std::vector<TabNavigation>& navigations,
       int selected_navigation,
       bool from_last_session,
       const std::string& extension_app_id,
       SessionStorageNamespace* session_storage_namespace);
 
   // Navigate to an index in the tab history, opening a new tab depending on the
   // disposition.
   bool NavigateToIndexWithDisposition(int index, WindowOpenDisposition disp);
 
@@ skipping 19 matching lines @@
   void Reload(WindowOpenDisposition disposition);
   void ReloadIgnoringCache(WindowOpenDisposition disposition);  // Shift-reload.
   void Home(WindowOpenDisposition disposition);
   void OpenCurrentURL();
   void Stop();
   // Window management commands
   void NewWindow();
   void NewIncognitoWindow();
   void CloseWindow();
   void NewTab();
-  void CloseTab();
+  virtual void CloseTab();
   void SelectNextTab();
   void SelectPreviousTab();
   void OpenTabpose();
   void MoveTabNext();
   void MoveTabPrevious();
   void SelectNumberedTab(int index);
   void SelectLastTab();
   void DuplicateTab();
   void WriteCurrentURLToClipboard();
   void ConvertPopupToTabbedBrowser();
@@ skipping 683 matching lines @@
   // and we install ourselves as an observer.
   TabRestoreService* tab_restore_service_;
 
   scoped_ptr<InstantController> instant_;
   scoped_ptr<InstantUnloadHandler> instant_unload_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_