[SYNC] Sessions datatype refactor. Most things related to sessions under-the-...

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2010 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 <vector>
@@ skipping 282 matching lines @@
       delete this;
       return;
     }
 
     if (browser_) {
       registrar_.Add(this, NotificationType::BROWSER_CLOSED,
                      Source<Browser>(browser_));
     }
   }
 
-  void RestoreForeignSession(std::vector<SessionWindow*>* windows) {
-    tab_loader_.reset(new TabLoader());
+  // Restore window(s) from a foreign session.
+  void RestoreForeignSession(
+      std::vector<SessionWindow*>::const_iterator begin,
+      std::vector<SessionWindow*>::const_iterator end) {
+    StartTabCreation();
     // Create a browser instance to put the restored tabs in.
-    bool has_tabbed_browser = false;
-    for (std::vector<SessionWindow*>::iterator i = (*windows).begin();
-        i != (*windows).end(); ++i) {
-      Browser* browser = NULL;
-      if (!has_tabbed_browser && (*i)->type == Browser::TYPE_NORMAL)
-        has_tabbed_browser = true;
-      browser = new Browser(static_cast<Browser::Type>((*i)->type),
-          profile_);
-      browser->set_override_bounds((*i)->bounds);
-      browser->set_maximized_state((*i)->is_maximized ?
-          Browser::MAXIMIZED_STATE_MAXIMIZED :
-          Browser::MAXIMIZED_STATE_UNMAXIMIZED);
-      browser->CreateBrowserWindow();
+    for (std::vector<SessionWindow*>::const_iterator i = begin;
+        i != end; ++i) {
+      Browser* browser = CreateRestoredBrowser(
+          static_cast<Browser::Type>((*i)->type),
+          (*i)->bounds,
+          (*i)->is_maximized);
 
       // Restore and show the browser.
       const int initial_tab_count = browser->tab_count();
       RestoreTabsToBrowser(*(*i), browser);
-      ShowBrowser(browser, initial_tab_count,
-          (*i)->selected_tab_index);
+      ShowBrowser(browser, initial_tab_count, (*i)->selected_tab_index);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
-    FinishedTabCreation(true, has_tabbed_browser);
+
+    // Always create in a new window
+    FinishedTabCreation(true, true);
+  }
+
+  // Restore a single tab from a foreign session.
+  // Note: we currently restore the tab to the last active browser.
+  void RestoreForeignTab(const SessionTab& tab) {
+    StartTabCreation();
+    Browser* current_browser =
+        browser_ ? browser_ : BrowserList::GetLastActive();
+    RestoreTab(tab, current_browser->tab_count(), current_browser);
+    NotifySessionServiceOfRestoredTabs(current_browser,
+                                       current_browser->tab_count());
+    FinishedTabCreation(true, true);
   }
 
   ~SessionRestoreImpl() {
     STLDeleteElements(&windows_);
     restoring = false;
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     switch (type.value) {
       case NotificationType::BROWSER_CLOSED:
         delete this;
         return;
 
       default:
         NOTREACHED();
         break;
     }
   }
 
  private:
+  // Invoked when beginning to create new tabs. Resets the tab_loader_.
+  void StartTabCreation() {
+    tab_loader_.reset(new TabLoader());
+  }
+
   // Invoked when done with creating all the tabs/browsers.
   //
   // |created_tabbed_browser| indicates whether a tabbed browser was created,
   // or we used an existing tabbed browser.
   //
   // If successful, this begins loading tabs and deletes itself when all tabs
   // have been loaded.
   void FinishedTabCreation(bool succeeded, bool created_tabbed_browser) {
     if (!created_tabbed_browser && always_create_tabbed_browser_) {
       Browser* browser = Browser::Create(profile_);
@@ skipping 34 matching lines @@
     ProcessSessionWindows(windows);
   }
 
   void ProcessSessionWindows(std::vector<SessionWindow*>* windows) {
     if (windows->empty()) {
       // Restore was unsuccessful.
       FinishedTabCreation(false, false);
       return;
     }
 
-    tab_loader_.reset(new TabLoader());
+    StartTabCreation();
 
     Browser* current_browser =
         browser_ ? browser_ : BrowserList::GetLastActive();
     // After the for loop this contains the last TABBED_BROWSER. Is null if no
     // tabbed browsers exist.
     Browser* last_browser = NULL;
     bool has_tabbed_browser = false;
     for (std::vector<SessionWindow*>::iterator i = windows->begin();
          i != windows->end(); ++i) {
       Browser* browser = NULL;
       if (!has_tabbed_browser && (*i)->type == Browser::TYPE_NORMAL)
         has_tabbed_browser = true;
       if (i == windows->begin() && (*i)->type == Browser::TYPE_NORMAL &&
           !clobber_existing_window_) {
         // If there is an open tabbed browser window, use it. Otherwise fall
         // through and create a new one.
         browser = current_browser;
         if (browser && (browser->type() != Browser::TYPE_NORMAL ||
                         browser->profile()->IsOffTheRecord())) {
           browser = NULL;
         }
       }
       if (!browser) {
-        browser = new Browser(static_cast<Browser::Type>((*i)->type), profile_);
-        browser->set_override_bounds((*i)->bounds);
-        browser->set_maximized_state((*i)->is_maximized ?
-            Browser::MAXIMIZED_STATE_MAXIMIZED :
-            Browser::MAXIMIZED_STATE_UNMAXIMIZED);
-        browser->CreateBrowserWindow();
+        browser = CreateRestoredBrowser(
+            static_cast<Browser::Type>((*i)->type),
+            (*i)->bounds,
+            (*i)->is_maximized);
       }
       if ((*i)->type == Browser::TYPE_NORMAL)
         last_browser = browser;
       const int initial_tab_count = browser->tab_count();
       RestoreTabsToBrowser(*(*i), browser);
       ShowBrowser(browser, initial_tab_count, (*i)->selected_tab_index);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // If we're restoring a session as the result of a crash and the session
     // included at least one tabbed browser, then close the browser window
     // that was opened when the user clicked to restore the session.
     if (clobber_existing_window_ && current_browser && has_tabbed_browser &&
         current_browser->type() == Browser::TYPE_NORMAL) {
       current_browser->CloseAllTabs();
     }
     if (last_browser && !urls_to_open_.empty())
       AppendURLsToBrowser(last_browser, urls_to_open_);
     // If last_browser is NULL and urls_to_open_ is non-empty,
     // FinishedTabCreation will create a new TabbedBrowser and add the urls to
     // it.
     FinishedTabCreation(true, has_tabbed_browser);
   }
 
   void RestoreTabsToBrowser(const SessionWindow& window, Browser* browser) {
     DCHECK(!window.tabs.empty());
     for (std::vector<SessionTab*>::const_iterator i = window.tabs.begin();
          i != window.tabs.end(); ++i) {
       const SessionTab& tab = *(*i);
-      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)));
-      tab_loader_->ScheduleLoad(
-          &browser->AddRestoredTab(tab.navigations,
-                                   static_cast<int>(i - window.tabs.begin()),
-                                   selected_index,
-                                   tab.extension_app_id,
-                                   false,
-                                   tab.pinned,
-                                   true,
-                                   NULL)->controller());
+      RestoreTab(tab, static_cast<int>(i - window.tabs.begin()), browser);
     }
   }
 
+  void RestoreTab(const SessionTab& tab,
+                  const int tab_index,
+                  Browser* browser) {
+    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)));
+    tab_loader_->ScheduleLoad(
+        &browser->AddRestoredTab(tab.navigations,
+                                 tab_index,
+                                 selected_index,
+                                 tab.extension_app_id,
+                                 false,
+                                 tab.pinned,
+                                 true,
+                                 NULL)->controller());
+  }
+
+  Browser* CreateRestoredBrowser(Browser::Type type,
+                                 gfx::Rect bounds,
+                                 bool is_maximized) {
+    Browser* browser = new Browser(type, profile_);
+    browser->set_override_bounds(bounds);
+    browser->set_maximized_state(is_maximized ?
+        Browser::MAXIMIZED_STATE_MAXIMIZED :
+        Browser::MAXIMIZED_STATE_UNMAXIMIZED);
+    browser->CreateBrowserWindow();
+    return browser;
+  }
+
   void ShowBrowser(Browser* browser,
                    int initial_tab_count,
                    int selected_session_index) {
     if (browser_ == browser) {
       browser->SelectTabContentsAt(browser->tab_count() - 1, true);
       return;
     }
 
     DCHECK(browser);
     DCHECK(browser->tab_count());
@@ skipping 103 matching lines @@
 void SessionRestore::RestoreSession(Profile* profile,
                                     Browser* browser,
                                     bool clobber_existing_window,
                                     bool always_create_tabbed_browser,
                                     const std::vector<GURL>& urls_to_open) {
   Restore(profile, browser, false, clobber_existing_window,
           always_create_tabbed_browser, urls_to_open);
 }
 
 // static
-void SessionRestore::RestoreForeignSessionWindows(Profile* profile,
-    std::vector<SessionWindow*>* windows) {
+void SessionRestore::RestoreForeignSessionWindows(
+    Profile* profile,
+    std::vector<SessionWindow*>::const_iterator begin,
+    std::vector<SessionWindow*>::const_iterator end) {
   // Create a SessionRestore object to eventually restore the tabs.
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
       static_cast<Browser*>(NULL), true, false, true, gurls);
-  restorer.RestoreForeignSession(windows);
+  restorer.RestoreForeignSession(begin, end);
+}
+
+// static
+void SessionRestore::RestoreForeignSessionTab(Profile* profile,
+    const SessionTab& tab) {
+  // Create a SessionRestore object to eventually restore the tabs.
+  std::vector<GURL> gurls;
+  SessionRestoreImpl restorer(profile,
+      static_cast<Browser*>(NULL), true, false, true, gurls);
+  restorer.RestoreForeignTab(tab);
 }
 
 // static
 void SessionRestore::RestoreSessionSynchronously(
     Profile* profile,
     const std::vector<GURL>& urls_to_open) {
   Restore(profile, NULL, true, false, true, urls_to_open);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }