Moved NavigationManagerImpl serialization out of CRWSessionController.

ios/chrome/browser/tabs/tab_model.mm

 // 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.
 
 #import "ios/chrome/browser/tabs/tab_model.h"
 
 #include <list>
 #include <utility>
 #include <vector>
 
@@ skipping 48 matching lines @@
     @"kTabModelTabDeselectedNotification";
 NSString* const kTabModelNewTabWillOpenNotification =
     @"kTabModelNewTabWillOpenNotification";
 NSString* const kTabModelTabKey = @"tab";
 NSString* const kTabModelPageLoadSuccess = @"pageLoadSuccess";
 NSString* const kTabModelOpenInBackgroundKey = @"shouldOpenInBackground";
 
 namespace {
 
 // Updates CRWSessionCertificatePolicyManager's certificate policy cache.
-void UpdateCertificatePolicyCacheFromWebState(web::WebStateImpl* webState) {
+void UpdateCertificatePolicyCacheFromWebState(web::WebState* web_state) {
   DCHECK([NSThread isMainThread]);
-  DCHECK(webState);
+  DCHECK(web_state);
   scoped_refptr<web::CertificatePolicyCache> policy_cache =
-      web::BrowserState::GetCertificatePolicyCache(webState->GetBrowserState());
-  CRWSessionController* controller =
-      webState->GetNavigationManagerImpl().GetSessionController();
+      web::BrowserState::GetCertificatePolicyCache(
+          web_state->GetBrowserState());
+  // TODO(crbug.com/454984): Remove CRWSessionController usage once certificate
+  // policy manager is moved to NavigationManager.
+  CRWSessionController* controller = static_cast<web::WebStateImpl*>(web_state)
+                                         ->GetNavigationManagerImpl()
+                                         .GetSessionController();
   [[controller sessionCertificatePolicyManager]
       updateCertificatePolicyCache:policy_cache];
 }
 
 // Populates the certificate policy cache based on the current entries of the
 // given tabs.
 void RestoreCertificatePolicyCacheFromTabs(NSArray* tabs) {
   DCHECK([NSThread isMainThread]);
   for (Tab* tab in tabs) {
     UpdateCertificatePolicyCacheFromWebState(tab.webStateImpl);
@@ skipping 161 matching lines @@
     // important to the backend code to always have a sync window delegate.
     if (!_browserState->IsOffTheRecord()) {
       // Set up the usage recorder before tabs are created.
       _tabUsageRecorder.reset(new TabUsageRecorder(self));
     }
     _syncedWindowDelegate.reset(new TabModelSyncedWindowDelegate(self));
 
     _tabs.reset([[NSMutableArray alloc] init]);
     NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
     if (window) {
-      while (window.unclaimedSessions) {
-        std::unique_ptr<web::WebStateImpl> webState = [window nextSession];
+      web::WebState::CreateParams params(_browserState);
+      for (CRWNavigationManagerStorage* session in window.sessions) {
+        std::unique_ptr<web::WebState> webState =
+            web::WebState::Create(params, session);
         DCHECK_EQ(webState->GetBrowserState(), _browserState);
         // Restore the CertificatePolicyCache.
         UpdateCertificatePolicyCacheFromWebState(webState.get());
         // Create a new tab for each entry in the window. Don't send delegate
         // notifications for each restored tab, only when all done.
         base::scoped_nsobject<Tab> tab(
             [[Tab alloc] initWithWebState:std::move(webState) model:self]);
         [tab webController].usePlaceholderOverlay = YES;
         [tab fetchFavicon];
         [_tabs addObject:tab];
@@ skipping 39 matching lines @@
 }
 
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window {
   DCHECK(_browserState);
   DCHECK(window);
-  if (!window.unclaimedSessions)
+  NSArray* sessions = window.sessions;
+  if (!sessions.count)
     return NO;
   size_t oldCount = [_tabs count];
   size_t index = oldCount;
-  while (window.unclaimedSessions) {
-    std::unique_ptr<web::WebStateImpl> webState = [window nextSession];
+  web::WebState::CreateParams params(_browserState);
+  for (CRWNavigationManagerStorage* session in sessions) {
+    std::unique_ptr<web::WebState> webState =
+        web::WebState::Create(params, session);
     DCHECK_EQ(webState->GetBrowserState(), _browserState);
     Tab* tab = [self insertTabWithWebState:std::move(webState) atIndex:index++];
     tab.webController.usePlaceholderOverlay = YES;
     // Restore the CertificatePolicyCache. Note that after calling Pass()
     // |webState| is invalid, so we need to get the webstate from |tab|.
     UpdateCertificatePolicyCacheFromWebState(tab.webStateImpl);
   }
   DCHECK([_tabs count] > oldCount);
   // If any tab was restored, the saved selected tab must be selected.
   if ([_tabs count] > oldCount) {
@@ skipping 507 matching lines @@
 - (SessionWindowIOS*)windowForSavingSession {
   // Background tabs will already have their state preserved, but not the
   // fg tab. Do it now.
   [_currentTab recordStateInHistory];
 
   // Build the array of sessions. Copy the session objects as the saving will
   // be done on a separate thread.
   // TODO(crbug.com/661986): This could get expensive especially since this
   // window may never be saved (if another call comes in before the delay).
   SessionWindowIOS* window = [[[SessionWindowIOS alloc] init] autorelease];
-  for (Tab* tab in _tabs.get()) {
-    DCHECK(tab.webStateImpl);
-    std::unique_ptr<web::WebStateImpl> webStateCopy(
-        tab.webStateImpl->CopyForSessionWindow());
-    [window addSession:std::move(webStateCopy)];
+  for (Tab* tab in self) {
+    web::WebState* webState = tab.webState;
+    DCHECK(webState);
+    [window addSerializedSession:webState->BuildSerializedNavigationManager()];
   }
   window.selectedIndex = [self indexOfTab:_currentTab];
   return window;
 }
 
 - (BOOL)isNTPTab:(Tab*)tab {
   std::string host = tab.url.host();
   return host == kChromeUINewTabHost || host == kChromeUIBookmarksHost;
 }
 
@@ skipping 199 matching lines @@
   web::NavigationManager::WebLoadParams params(URL);
   params.referrer = referrer;
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   [[tab webController] loadWithParams:params];
   [tab webController].webUsageEnabled = webUsageEnabled_;
   [self insertTab:tab atIndex:index];
   return tab;
 }
 
 @end