[ios] Clean how WebUsageEnabled flag is restored for 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 103 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)));
 }
 
+// Factory of WebState for DeserializeWebStateList that wraps the method
+// web::WebState::CreateWithStorageSession and sets the WebState usage
+// enabled flag from |web_usage_enabled|.
+std::unique_ptr<web::WebState> CreateWebState(
+    BOOL web_usage_enabled,
+    web::WebState::CreateParams create_params,
+    CRWSessionStorage* session_storage) {
+  std::unique_ptr<web::WebState> web_state =
+      web::WebState::CreateWithStorageSession(create_params, session_storage);
+  web_state->SetWebUsageEnabled(web_usage_enabled);
+  return web_state;
+}
+
 }  // anonymous namespace
 
 @interface TabModelWebStateProxyFactory : NSObject<WebStateProxyFactory>
 @end
 
 @implementation TabModelWebStateProxyFactory
 
 - (id)proxyForWebState:(web::WebState*)webState {
   return LegacyTabHelper::GetTabForWebState(webState);
 }
@@ skipping 45 matching lines @@
 // method and restoring session in the initialiser.
 - (BOOL)restoreSessionWindow:(SessionWindowIOS*)window
                 persistState:(BOOL)persistState;
 
 @end
 
 @implementation TabModel
 
 @synthesize browserState = _browserState;
 @synthesize sessionID = _sessionID;
-@synthesize webUsageEnabled = webUsageEnabled_;
+@synthesize webUsageEnabled = _webUsageEnabled;
 
 #pragma mark - Overriden
 
 - (void)dealloc {
   // Make sure the tabs do clean after themselves. It is important for
   // removeObserver: to be called first otherwise a lot of unecessary work will
   // happen on -closeAllTabs.
   DCHECK([_observers empty]);
 
   // browserStateDestroyed should always have been called before destruction.
@@ skipping 289 matching lines @@
     _webStateList->InsertWebState(insertion_index, std::move(webState));
     if (parentTab.webState) {
       _webStateList->SetOpenerOfWebStateAt(insertion_index,
                                            WebStateOpener(parentTab.webState));
     }
   }
 
   Tab* tab = LegacyTabHelper::GetTabForWebState(webStatePtr);
   DCHECK(tab);
 
-  webStatePtr->SetWebUsageEnabled(webUsageEnabled_ ? true : false);
+  webStatePtr->SetWebUsageEnabled(_webUsageEnabled ? true : false);
 
   if (!inBackground && _tabUsageRecorder)
     _tabUsageRecorder->TabCreatedForSelection(tab);
 
   webStatePtr->GetNavigationManager()->LoadURLWithParams(loadParams);
 
   // Force the page to start loading even if it's in the background.
   // TODO(crbug.com/705819): Remove this call.
-  if (webUsageEnabled_)
+  if (_webUsageEnabled)
     webStatePtr->GetView();
 
   NSDictionary* userInfo = @{
     kTabModelTabKey : tab,
     kTabModelOpenInBackgroundKey : @(inBackground),
   };
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabModelNewTabWillOpenNotification
                     object:self
                   userInfo:userInfo];
@@ skipping 59 matching lines @@
   [_observers tabModel:self didChangeTabSnapshot:tab withImage:image];
 }
 
 - (void)resetAllWebViews {
   for (Tab* tab in self) {
     [tab.webController reinitializeWebViewAndReload:(tab == self.currentTab)];
   }
 }
 
 - (void)setWebUsageEnabled:(BOOL)webUsageEnabled {
-  if (webUsageEnabled_ == webUsageEnabled)
+  if (_webUsageEnabled == webUsageEnabled)
     return;
-  webUsageEnabled_ = webUsageEnabled;
+  _webUsageEnabled = webUsageEnabled;
   for (int index = 0; index < _webStateList->count(); ++index) {
     web::WebState* webState = _webStateList->GetWebStateAt(index);
-    webState->SetWebUsageEnabled(webUsageEnabled_ ? true : false);
+    webState->SetWebUsageEnabled(_webUsageEnabled ? true : false);
   }
 }
 
 - (void)setPrimary:(BOOL)primary {
   if (_tabUsageRecorder)
     _tabUsageRecorder->RecordPrimaryTabModelChange(primary, self.currentTab);
 }
 
 - (NSSet*)currentlyReferencedExternalFiles {
   NSMutableSet* referencedFiles = [NSMutableSet set];
@@ skipping 97 matching lines @@
   DCHECK(window);
 
   if (!window.sessions.count)
     return NO;
 
   int oldCount = _webStateList->count();
   DCHECK_GE(oldCount, 0);
 
   web::WebState::CreateParams createParams(_browserState);
   DeserializeWebStateList(
-      _webStateList.get(), window, webUsageEnabled_,
-      base::BindRepeating(&web::WebState::CreateWithStorageSession,
-                          createParams));
+      _webStateList.get(), window,
+      base::BindRepeating(&CreateWebState, _webUsageEnabled, createParams));
 
   DCHECK_GT(_webStateList->count(), oldCount);
   int restoredCount = _webStateList->count() - oldCount;
   DCHECK_EQ(window.sessions.count, static_cast<NSUInteger>(restoredCount));
 
   scoped_refptr<web::CertificatePolicyCache> policyCache =
       web::BrowserState::GetCertificatePolicyCache(_browserState);
 
   NSMutableArray<Tab*>* restoredTabs =
       [[NSMutableArray alloc] initWithCapacity:window.sessions.count];
 
   for (int index = oldCount; index < _webStateList->count(); ++index) {
     web::WebState* webState = _webStateList->GetWebStateAt(index);
     Tab* tab = LegacyTabHelper::GetTabForWebState(webState);
 
-    webState->SetWebUsageEnabled(webUsageEnabled_ ? true : false);
+    webState->SetWebUsageEnabled(_webUsageEnabled ? true : false);
     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];
   }
 
   // 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);
   return closedNTPTab;
 }
 
 #pragma mark - Notification Handlers
 
 // Called when UIApplicationWillResignActiveNotification is received.
 - (void)willResignActive:(NSNotification*)notify {
-  if (webUsageEnabled_ && self.currentTab) {
+  if (_webUsageEnabled && self.currentTab) {
     [[SnapshotCache sharedInstance]
         willBeSavedGreyWhenBackgrounding:self.currentTab.tabId];
   }
 }
 
 // Called when UIApplicationDidEnterBackgroundNotification is received.
 - (void)applicationDidEnterBackground:(NSNotification*)notify {
   if (!_browserState)
     return;
 
   // Evict all the certificate policies except for the current entries of the
   // active sessions.
   CleanCertificatePolicyCache(
       &_clearPoliciesTaskTracker,
       web::WebThread::GetTaskRunnerForThread(web::WebThread::IO),
       web::BrowserState::GetCertificatePolicyCache(_browserState),
       _webStateList.get());
 
   if (_tabUsageRecorder)
     _tabUsageRecorder->AppDidEnterBackground();
 
   // Normally, the session is saved after some timer expires but since the app
   // is about to enter the background send YES to save the session immediately.
   [self saveSessionImmediately:YES];
 
   // Write out a grey version of the current website to disk.
-  if (webUsageEnabled_ && self.currentTab) {
+  if (_webUsageEnabled && self.currentTab) {
     [[SnapshotCache sharedInstance]
         saveGreyInBackgroundForSessionID:self.currentTab.tabId];
   }
 }
 
 // Called when UIApplicationWillEnterForegroundNotification is received.
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end