[ios] Add free function to (de)serialise WebStateList.

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 <cstdint>
 #include <utility>
 #include <vector>
 
@@ skipping 28 matching lines @@
 #import "ios/chrome/browser/tabs/tab_model_observers_bridge.h"
 #import "ios/chrome/browser/tabs/tab_model_selected_tab_observer.h"
 #import "ios/chrome/browser/tabs/tab_model_synced_window_delegate.h"
 #import "ios/chrome/browser/tabs/tab_model_web_state_list_delegate.h"
 #import "ios/chrome/browser/tabs/tab_parenting_observer.h"
 #import "ios/chrome/browser/xcallback_parameters.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_fast_enumeration_helper.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_metrics_observer.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_observer.h"
+#import "ios/shared/chrome/browser/tabs/web_state_list_serialization.h"
 #import "ios/shared/chrome/browser/tabs/web_state_opener.h"
 #include "ios/web/public/browser_state.h"
 #include "ios/web/public/certificate_policy_cache.h"
 #include "ios/web/public/navigation_item.h"
 #import "ios/web/public/navigation_manager.h"
 #import "ios/web/public/serializable_user_data_manager.h"
 #include "ios/web/public/web_state/session_certificate_policy_cache.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/web_state_impl.h"
@@ skipping 10 matching lines @@
 NSString* const kTabModelTabDeselectedNotification =
     @"kTabModelTabDeselectedNotification";
 NSString* const kTabModelNewTabWillOpenNotification =
     @"kTabModelNewTabWillOpenNotification";
 NSString* const kTabModelTabKey = @"tab";
 NSString* const kTabModelPageLoadSuccess = @"pageLoadSuccess";
 NSString* const kTabModelOpenInBackgroundKey = @"shouldOpenInBackground";
 
 namespace {
 
-// The key under which the opener Tab ID is stored in the WebState's
-// serializable user data.
-NSString* const kOpenerIDKey = @"OpenerID";
-
-// The key under which the opener navigation index is stored in the WebState's
-// serializable user data.
-NSString* const kOpenerNavigationIndexKey = @"OpenerNavigationIndex";
-
 // Updates CRWSessionCertificatePolicyManager's certificate policy cache.
 void UpdateCertificatePolicyCacheFromWebState(
     const scoped_refptr<web::CertificatePolicyCache>& policy_cache,
     const web::WebState* web_state) {
   DCHECK(web_state);
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   web_state->GetSessionCertificatePolicyCache()->UpdateCertificatePolicyCache(
       policy_cache);
 }
 
@@ skipping 20 matching lines @@
   DCHECK(web_state_list);
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   task_tracker->PostTaskAndReply(
       task_runner.get(), FROM_HERE,
       base::Bind(&web::CertificatePolicyCache::ClearCertificatePolicies,
                  policy_cache),
       base::Bind(&RestoreCertificatePolicyCacheFromModel, policy_cache,
                  base::Unretained(web_state_list)));
 }
 
-// Internal helper function returning the opener for a given Tab by
-// checking the associated Tab tabId (should be removed once the opener
-// is passed to the insertTab:atIndex: and replaceTab:withTab: methods).
-WebStateOpener GetOpenerForTab(id<NSFastEnumeration> tabs, Tab* tab) {
-  web::SerializableUserDataManager* user_data_manager =
-      web::SerializableUserDataManager::FromWebState(tab.webState);
-
-  NSString* opener_id = base::mac::ObjCCast<NSString>(
-      user_data_manager->GetValueForSerializationKey(kOpenerIDKey));
-  if (!opener_id || ![opener_id length])
-    return WebStateOpener(nullptr);
-
-  NSNumber* boxed_opener_navigation_index = base::mac::ObjCCast<NSNumber>(
-      user_data_manager->GetValueForSerializationKey(
-          kOpenerNavigationIndexKey));
-  if (!boxed_opener_navigation_index)
-    return WebStateOpener(nullptr);
-
-  for (Tab* current_tab in tabs) {
-    if ([opener_id isEqualToString:current_tab.tabId]) {
-      return WebStateOpener(current_tab.webState,
-                            [boxed_opener_navigation_index intValue]);
-    }
-  }
-
-  return WebStateOpener(nullptr);
-}
-
 }  // anonymous namespace
 
 @interface TabModelWebStateProxyFactory : NSObject<WebStateProxyFactory>
 @end
 
 @implementation TabModelWebStateProxyFactory
 
 - (id)proxyForWebState:(web::WebState*)webState {
   return LegacyTabHelper::GetTabForWebState(webState);
 }
@@ skipping 528 matching lines @@
 
 - (SessionWindowIOS*)windowForSavingSession {
   // Background tabs will already have their state preserved, but not the
   // fg tab. Do it now.
   [self.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).
-  NSMutableArray<CRWSessionStorage*>* sessions =
-      [NSMutableArray arrayWithCapacity:[self count]];
-
-  for (int index = 0; index < _webStateList->count(); ++index) {
-    web::WebState* webState = _webStateList->GetWebStateAt(index);
-    web::SerializableUserDataManager* userDataManager =
-        web::SerializableUserDataManager::FromWebState(webState);
-
-    WebStateOpener opener = _webStateList->GetOpenerOfWebStateAt(index);
-    if (opener.opener) {
-      Tab* parentTab = LegacyTabHelper::GetTabForWebState(opener.opener);
-      userDataManager->AddSerializableData(parentTab.tabId, kOpenerIDKey);
-      userDataManager->AddSerializableData(@(opener.navigation_index),
-                                           kOpenerNavigationIndexKey);
-    } else {
-      userDataManager->AddSerializableData([NSNull null], kOpenerIDKey);
-      userDataManager->AddSerializableData([NSNull null],
-                                           kOpenerNavigationIndexKey);
-    }
-
-    [sessions addObject:webState->BuildSessionStorage()];
-  }
-
   return [[[SessionWindowIOS alloc]
-      initWithSessions:sessions
+      initWithSessions:SerializeWebStateList(_webStateList.get())
          selectedIndex:[self indexOfTab:self.currentTab]] autorelease];
 }
 
 - (void)postNotificationName:(NSString*)notificationName withTab:(Tab*)tab {
   // A scoped_nsobject is used rather than an NSDictionary with static
   // initializer dictionaryWithObject, because that approach adds the dictionary
   // to the autorelease pool, which in turn holds Tab alive longer than
   // necessary.
   base::scoped_nsobject<NSDictionary> userInfo(
       [[NSDictionary alloc] initWithObjectsAndKeys:tab, kTabModelTabKey, nil]);
   [[NSNotificationCenter defaultCenter] postNotificationName:notificationName
                                                       object:self
                                                     userInfo:userInfo];
 }
 
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window
                 persistState:(BOOL)persistState {
   DCHECK(_browserState);
   DCHECK(window);
 
   NSArray* sessions = window.sessions;
   if (!sessions.count)
     return NO;
 
   int oldCount = _webStateList->count();
   DCHECK_GE(oldCount, 0);
 
-  web::WebState::CreateParams params(_browserState);
+  web::WebState::CreateParams createParams(_browserState);
+  DeserializeWebStateList(
+      _webStateList.get(), sessions,
+      base::BindRepeating(&web::WebState::CreateWithStorageSession,
+                          createParams));
+
+  DCHECK_GT(_webStateList->count(), oldCount);
+  int restoredCount = _webStateList->count() - oldCount;
+  DCHECK_EQ(sessions.count, static_cast<NSUInteger>(restoredCount));
+
   scoped_refptr<web::CertificatePolicyCache> policyCache =
       web::BrowserState::GetCertificatePolicyCache(_browserState);
 
   base::scoped_nsobject<NSMutableArray<Tab*>> restoredTabs(
       [[NSMutableArray alloc] initWithCapacity:sessions.count]);
 
-  // Recreate all the restored Tabs and add them to the WebStateList without
-  // any opener-opened relationship (as the n-th restored Tab opener may be
-  // at an index larger than n). Then in a second pass fix the openers.
-  for (CRWSessionStorage* session in sessions) {
-    std::unique_ptr<web::WebState> webState =
-        web::WebState::CreateWithStorageSession(params, session);
-    _webStateList->InsertWebState(_webStateList->count(), std::move(webState));
-  }
-
   for (int index = oldCount; index < _webStateList->count(); ++index) {
     web::WebState* webState = _webStateList->GetWebStateAt(index);
     Tab* tab = LegacyTabHelper::GetTabForWebState(webState);
+
     tab.webController.webUsageEnabled = webUsageEnabled_;
     tab.webController.usePlaceholderOverlay = YES;
 
     // Restore the CertificatePolicyCache (note that webState is invalid after
     // passing it via move semantic to -initWithWebState:model:).
     UpdateCertificatePolicyCacheFromWebState(policyCache, [tab webState]);
     [restoredTabs addObject:tab];
   }
 
-  DCHECK_EQ(sessions.count, [restoredTabs count]);
-  DCHECK_GT(_webStateList->count(), oldCount);
-
-  // Fix openers now that all Tabs have been restored. Only look for an opener
-  // Tab in the newly restored Tabs and not in the already open Tabs.
-  for (int index = oldCount; index < _webStateList->count(); ++index) {
-    DCHECK_GE(index, oldCount);
-    NSUInteger tabIndex = static_cast<NSUInteger>(index - oldCount);
-    Tab* tab = [restoredTabs objectAtIndex:tabIndex];
-    WebStateOpener opener = GetOpenerForTab(restoredTabs.get(), tab);
-    if (opener.opener)
-      _webStateList->SetOpenerOfWebStateAt(index, opener);
-  }
-
   // Update the selected tab if there was a selected Tab in the saved session.
   if (window.selectedIndex != NSNotFound) {
     NSUInteger selectedIndex = window.selectedIndex + oldCount;
     DCHECK_LT(selectedIndex, self.count);
     DCHECK([self tabAtIndex:selectedIndex]);
 
     if (persistState && self.currentTab)
       [self.currentTab recordStateInHistory];
     _webStateList->ActivateWebStateAt(static_cast<int>(selectedIndex));
   }
 
   // If there was only one tab and it was the new tab page, clobber it.
   BOOL closedNTPTab = NO;
   if (oldCount == 1) {
     Tab* tab = [self tabAtIndex:0];
     if (tab.url == GURL(kChromeUINewTabURL)) {
       [self closeTab:tab];
       closedNTPTab = YES;
       oldCount = 0;
     }
   }
   if (_tabUsageRecorder)
-    _tabUsageRecorder->InitialRestoredTabs(self.currentTab, restoredTabs);
+    _tabUsageRecorder->InitialRestoredTabs(self.currentTab, restoredTabs.get());
   return closedNTPTab;
 }
 
 #pragma mark - Notification Handlers
 
 // Called when UIApplicationWillResignActiveNotification is received.
 - (void)willResignActive:(NSNotification*)notify {
   if (webUsageEnabled_ && self.currentTab) {
     [[SnapshotCache sharedInstance]
         willBeSavedGreyWhenBackgrounding:self.currentTab.tabId];
@@ skipping 28 matching lines @@
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end