Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

chrome/browser/sessions/session_restore.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/sessions/session_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
+#include "chrome/browser/ui/browser_tabrestore.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 220 matching lines @@
     NavigationController* tab = tabs_to_load_.front();
     DCHECK(tab);
     tabs_loading_.insert(tab);
     if (tabs_loading_.size() > max_parallel_tab_loads_)
       max_parallel_tab_loads_ = tabs_loading_.size();
     tabs_to_load_.pop_front();
     tab->LoadIfNecessary();
     content::WebContents* contents = tab->GetWebContents();
     if (contents) {
       Browser* browser = browser::FindBrowserWithWebContents(contents);
-      if (browser && browser->GetActiveWebContents() != contents) {
+      if (browser && chrome::GetActiveWebContents(browser) != contents) {
         // By default tabs are marked as visible. As only the active tab is
         // visible we need to explicitly tell non-active tabs they are hidden.
         // Without this call non-active tabs are not marked as backgrounded.
         //
         // NOTE: We need to do this here rather than when the tab is added to
         // the Browser as at that time not everything has been created, so that
         // the call would do nothing.
         contents->WasHidden();
       }
     }
@@ skipping 266 matching lines @@
       // Restore and show the browser.
       const int initial_tab_count = 0;
       int selected_tab_index = std::max(
           0,
           std::min((*i)->selected_tab_index,
                    static_cast<int>((*i)->tabs.size()) - 1));
       selected_tab_index =
           RestoreTabsToBrowser(*(*i), browser, selected_tab_index);
       ShowBrowser(browser, selected_tab_index);
       tab_loader_->TabIsLoading(
-          &browser->GetActiveWebContents()->GetController());
+          &chrome::GetActiveWebContents(browser)->GetController());
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // Always create in a new window
     FinishedTabCreation(true, true);
   }
 
   // Restore a single tab from a foreign session.
   // Opens in the tab in the last active browser, unless disposition is
   // NEW_WINDOW, in which case the tab will be opened in a new browser.
   void RestoreForeignTab(const SessionTab& tab,
                          WindowOpenDisposition disposition) {
     DCHECK(!tab.navigations.empty());
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index,
                  static_cast<int>(tab.navigations.size() - 1)));
 
     bool use_new_window = disposition == NEW_WINDOW;
 
     Browser* browser = use_new_window ? Browser::Create(profile_) : browser_;
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     if (disposition == CURRENT_TAB) {
       DCHECK(!use_new_window);
-      browser->ReplaceRestoredTab(tab.navigations,
-                                  selected_index,
-                                  true,
-                                  tab.extension_app_id,
-                                  NULL);
+      chrome::ReplaceRestoredTab(browser,
+                                 tab.navigations,
+                                 selected_index,
+                                 true,
+                                 tab.extension_app_id,
+                                 NULL);
     } else {
       int tab_index = use_new_window ? 0 : browser->active_index() + 1;
-      WebContents* web_contents = browser->AddRestoredTab(
+      WebContents* web_contents = chrome::AddRestoredTab(
+          browser,
           tab.navigations,
           tab_index,
           selected_index,
           tab.extension_app_id,
           false,  // selected
           tab.pinned,
           true,
           NULL);
       // Start loading the tab immediately.
       web_contents->GetController().LoadIfNecessary();
     }
 
     if (use_new_window) {
-      browser->ActivateTabAt(0, true);
+      chrome::ActivateTabAt(browser, 0, true);
       browser->window()->Show();
     }
     NotifySessionServiceOfRestoredTabs(browser, browser->tab_count());
 
     // Since FinishedTabCreation() is not called here, |this| will leak if we
     // are not in sychronous mode.
     DCHECK(synchronous_);
   }
 
   ~SessionRestoreImpl() {
@@ skipping 161 matching lines @@
             (*i)->bounds,
             show_state,
             (*i)->app_name);
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-CreateRestoredBrowser-End", false);
 #endif
       }
       if ((*i)->type == Browser::TYPE_TABBED)
         last_browser = browser;
-      WebContents* active_tab = browser->GetActiveWebContents();
+      WebContents* active_tab = chrome::GetActiveWebContents(browser);
       int initial_tab_count = browser->tab_count();
       int selected_tab_index = std::max(
           0,
           std::min((*i)->selected_tab_index,
                    static_cast<int>((*i)->tabs.size()) - 1));
       selected_tab_index =
           RestoreTabsToBrowser(*(*i), browser, selected_tab_index);
       ShowBrowser(browser, selected_tab_index);
       if (clobber_existing_tab_ && i == windows->begin() &&
           (*i)->type == Browser::TYPE_TABBED && active_tab &&
           browser == browser_ && browser->tab_count() > initial_tab_count) {
-        browser->CloseTabContents(active_tab);
+        chrome::CloseWebContents(browser, active_tab);
         active_tab = NULL;
       }
       tab_loader_->TabIsLoading(
-          &browser->GetActiveWebContents()->GetController());
+          &chrome::GetActiveWebContents(browser)->GetController());
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     if (last_browser && !urls_to_open_.empty())
       AppendURLsToBrowser(last_browser, urls_to_open_);
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-CreatingTabs-End", false);
 #endif
     // If last_browser is NULL and urls_to_open_ is non-empty,
@@ skipping 31 matching lines @@
     WebContents* selected_web_contents = NULL;
     for (int i = 0; i < static_cast<int>(window.tabs.size()); ++i) {
       const SessionTab& tab = *(window.tabs[i]);
       // Don't schedule a load for the selected tab, as ShowBrowser() will do
       // that.
       if (i == selected_tab_index)
         selected_web_contents = RestoreTab(tab, i, browser, false);
       else
         RestoreTab(tab, i, browser, true);
     }
-    if (selected_web_contents) {
-      return browser->GetIndexOfController(
-          &selected_web_contents->GetController());
-    }
-    return 0;
+    return selected_web_contents ?
+        chrome::GetIndexOfTab(browser, selected_web_contents) : 0;
   }
 
   WebContents* RestoreTab(const SessionTab& tab,
                           const int tab_index,
                           Browser* browser,
                           bool schedule_load) {
     DCHECK(!tab.navigations.empty());
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index,
                  static_cast<int>(tab.navigations.size() - 1)));
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     // Associate sessionStorage (if any) to the restored tab.
     scoped_refptr<content::SessionStorageNamespace> session_storage_namespace;
     if (!tab.session_storage_persistent_id.empty()) {
       session_storage_namespace =
           content::BrowserContext::GetDOMStorageContext(profile_)->
           RecreateSessionStorage(tab.session_storage_persistent_id);
     }
 
     WebContents* web_contents =
-        browser->AddRestoredTab(tab.navigations,
-                                tab_index,
-                                selected_index,
-                                tab.extension_app_id,
-                                false,  // select
-                                tab.pinned,
-                                true,
-                                session_storage_namespace.get());
+        chrome::AddRestoredTab(browser,
+                               tab.navigations,
+                               tab_index,
+                               selected_index,
+                               tab.extension_app_id,
+                               false,  // select
+                               tab.pinned,
+                               true,
+                               session_storage_namespace.get());
     // Regression check: check that the tab didn't start loading right away. The
     // focused tab will be loaded by Browser, and TabLoader will load the rest.
     DCHECK(web_contents->GetController().NeedsReload());
 
     // Set up the file access rights for the selected navigation entry.
     const int id = web_contents->GetRenderProcessHost()->GetID();
     const int read_file_permissions =
         base::PLATFORM_FILE_OPEN |
         base::PLATFORM_FILE_READ |
         base::PLATFORM_FILE_EXCLUSIVE_READ |
@@ skipping 21 matching lines @@
     params.app_name = app_name;
     params.initial_bounds = bounds;
     params.initial_show_state = show_state;
     params.is_session_restore = true;
     return Browser::CreateWithParams(params);
   }
 
   void ShowBrowser(Browser* browser, int selected_tab_index) {
     DCHECK(browser);
     DCHECK(browser->tab_count());
-    browser->ActivateTabAt(selected_tab_index, true);
+    chrome::ActivateTabAt(browser, selected_tab_index, true);
 
     if (browser_ == browser)
       return;
 
     browser->window()->Show();
     browser->set_is_session_restore(false);
 
     // TODO(jcampan): http://crbug.com/8123 we should not need to set the
     //                initial focus explicitly.
-    browser->GetActiveWebContents()->GetView()->SetInitialFocus();
+    chrome::GetActiveWebContents(browser)->GetView()->SetInitialFocus();
 
     if (!browser_shown_) {
       browser_shown_ = true;
       base::TimeDelta time_to_first_show =
           base::TimeTicks::Now() - restore_started_;
       UMA_HISTOGRAM_CUSTOM_TIMES(
           "SessionRestore.TimeToFirstShow",
           time_to_first_show,
           base::TimeDelta::FromMilliseconds(10),
           base::TimeDelta::FromSeconds(1000),
           100);
     }
   }
 
   // Appends the urls in |urls| to |browser|.
   void AppendURLsToBrowser(Browser* browser,
                            const std::vector<GURL>& urls) {
     for (size_t i = 0; i < urls.size(); ++i) {
       int add_types = TabStripModel::ADD_FORCE_INDEX;
       if (i == 0)
         add_types |= TabStripModel::ADD_ACTIVE;
-      int index = browser->GetIndexForInsertionDuringRestore(i);
+      int index = chrome::GetIndexForInsertionDuringRestore(browser, i);
       browser::NavigateParams params(browser, urls[i],
                                      content::PAGE_TRANSITION_START_PAGE);
       params.disposition = i == 0 ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
       params.tabstrip_index = index;
       params.tabstrip_add_types = add_types;
       browser::Navigate(&params);
     }
   }
 
   // Invokes TabRestored on the SessionService for all tabs in browser after
   // initial_count.
   void NotifySessionServiceOfRestoredTabs(Browser* browser, int initial_count) {
     SessionService* session_service =
         SessionServiceFactory::GetForProfile(profile_);
     if (!session_service)
       return;
     for (int i = initial_count; i < browser->tab_count(); ++i)
-      session_service->TabRestored(browser->GetTabContentsAt(i),
-                                   browser->IsTabPinned(i));
+      session_service->TabRestored(chrome::GetTabContentsAt(browser, i),
+                                   browser->tab_strip_model()->IsTabPinned(i));
   }
 
   // The profile to create the sessions for.
   Profile* profile_;
 
   // The first browser to restore to, may be null.
   Browser* browser_;
 
   // Whether or not restore is synchronous.
   const bool synchronous_;
@@ skipping 91 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }