Abstract content::SessionStorageNamespace from core TabRestore code

chrome/browser/sessions/tab_restore_service_helper.cc

 // Copyright 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/tab_restore_service_helper.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_observer.h"
 #include "components/sessions/content/content_serialized_navigation_builder.h"
 #include "components/sessions/core/tab_restore_service_client.h"
 #include "components/sessions/session_types.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
 // TabRestoreServiceHelper::Observer -------------------------------------------
 
 TabRestoreServiceHelper::Observer::~Observer() {}
 
@@ skipping 178 matching lines @@
     Window* window = static_cast<Window*>(entry);
 
     // When restoring a window, either the entire window can be restored, or a
     // single tab within it. If the entry's ID matches the one to restore, then
     // the entire window will be restored.
     if (!restoring_tab_in_window) {
       delegate = client_->CreateTabRestoreServiceDelegate(host_desktop_type,
                                                           window->app_name);
       for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
         const Tab& tab = window->tabs[tab_i];
+        DCHECK(tab.from_last_session || tab.client_data);
         WebContents* restored_tab = delegate->AddRestoredTab(
-            tab.navigations,
-            delegate->GetTabCount(),
-            tab.current_navigation_index,
-            tab.extension_app_id,
-            static_cast<int>(tab_i) == window->selected_tab_index,
-            tab.pinned,
-            tab.from_last_session,
-            tab.session_storage_namespace.get(),
+            tab.navigations, delegate->GetTabCount(),
+            tab.current_navigation_index, tab.extension_app_id,
+            static_cast<int>(tab_i) == window->selected_tab_index, tab.pinned,
+            tab.from_last_session, tab.client_data.get(),
             tab.user_agent_override);
         if (restored_tab) {
           restored_tab->GetController().LoadIfNecessary();
           client_->OnTabRestored(
               tab.navigations.at(tab.current_navigation_index).virtual_url());
           web_contents.push_back(restored_tab);
         }
       }
       // All the window's tabs had the same former browser_id.
       if (window->tabs[0].has_browser()) {
@@ skipping 156 matching lines @@
   if (tab->current_navigation_index == -1 && entry_count > 0)
     tab->current_navigation_index = 0;
   tab->tabstrip_index = index;
 
   tab->extension_app_id =
       client_->GetExtensionAppIDForWebContents(controller->GetWebContents());
 
   tab->user_agent_override =
       controller->GetWebContents()->GetUserAgentOverride();
 
-  // TODO(ajwong): This does not correctly handle storage for isolated apps.
-  tab->session_storage_namespace =
-      controller->GetDefaultSessionStorageNamespace();
+  tab->client_data =
+      client_->GetTabClientDataForWebContents(controller->GetWebContents());
 
   // Delegate may be NULL during unit tests.
   if (delegate) {
     tab->browser_id = delegate->GetSessionID().id();
     tab->pinned = delegate->IsTabPinned(tab->tabstrip_index);
   }
 }
 
 TabRestoreServiceDelegate* TabRestoreServiceHelper::RestoreTab(
     const Tab& tab,
     TabRestoreServiceDelegate* delegate,
     int host_desktop_type,
     WindowOpenDisposition disposition,
     WebContents** contents) {
+  DCHECK(tab.from_last_session || tab.client_data);
   WebContents* web_contents;
   if (disposition == CURRENT_TAB && delegate) {
     web_contents = delegate->ReplaceRestoredTab(
-        tab.navigations,
-        tab.current_navigation_index,
-        tab.from_last_session,
-        tab.extension_app_id,
-        tab.session_storage_namespace.get(),
-        tab.user_agent_override);
+        tab.navigations, tab.current_navigation_index, tab.from_last_session,
+        tab.extension_app_id, tab.client_data.get(), tab.user_agent_override);
   } else {
     // We only respsect the tab's original browser if there's no disposition.
     if (disposition == UNKNOWN && tab.has_browser()) {
       delegate = client_->FindTabRestoreServiceDelegateWithID(
           tab.browser_id, host_desktop_type);
     }
 
     int tab_index = -1;
 
     // |delegate| will be NULL in cases where one isn't already available (eg,
     // when invoked on Mac OS X with no windows open). In this case, create a
     // new browser into which we restore the tabs.
     if (delegate && disposition != NEW_WINDOW) {
       tab_index = tab.tabstrip_index;
     } else {
       delegate = client_->CreateTabRestoreServiceDelegate(host_desktop_type,
                                                           std::string());
       if (tab.has_browser())
         UpdateTabBrowserIDs(tab.browser_id, delegate->GetSessionID().id());
     }
 
     // Place the tab at the end if the tab index is no longer valid or
     // we were passed a specific disposition.
     if (tab_index < 0 || tab_index > delegate->GetTabCount() ||
         disposition != UNKNOWN) {
       tab_index = delegate->GetTabCount();
     }
 
-    web_contents = delegate->AddRestoredTab(tab.navigations,
-                                            tab_index,
-                                            tab.current_navigation_index,
-                                            tab.extension_app_id,
-                                            disposition != NEW_BACKGROUND_TAB,
-                                            tab.pinned,
-                                            tab.from_last_session,
-                                            tab.session_storage_namespace.get(),
-                                            tab.user_agent_override);
+    web_contents = delegate->AddRestoredTab(
+        tab.navigations, tab_index, tab.current_navigation_index,
+        tab.extension_app_id, disposition != NEW_BACKGROUND_TAB, tab.pinned,
+        tab.from_last_session, tab.client_data.get(), tab.user_agent_override);
     web_contents->GetController().LoadIfNecessary();
   }
   client_->OnTabRestored(
       tab.navigations.at(tab.current_navigation_index).virtual_url());
   if (contents)
     *contents = web_contents;
 
   return delegate;
 }
 
@@ skipping 77 matching lines @@
       Tab* tab = static_cast<Tab*>(entry);
       if (tab->browser_id == old_id)
         tab->browser_id = new_id;
     }
   }
 }
 
 base::Time TabRestoreServiceHelper::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : base::Time::Now();
 }