Make certificate policy restoration thread-safe.

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>
 
 #include "base/bind.h"
 #import "base/ios/crb_protocol_observers.h"
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/task/cancelable_task_tracker.h"
 #include "components/sessions/core/serialized_navigation_entry.h"
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/ios/ios_live_tab.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #import "ios/chrome/browser/chrome_url_util.h"
 #import "ios/chrome/browser/metrics/tab_usage_recorder.h"
 #include "ios/chrome/browser/sessions/ios_chrome_tab_restore_service_factory.h"
 #import "ios/chrome/browser/sessions/session_service.h"
@@ skipping 30 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::WebState* web_state) {
-  DCHECK([NSThread isMainThread]);
+void UpdateCertificatePolicyCacheFromWebState(
+    const scoped_refptr<web::CertificatePolicyCache>& policy_cache,
+    web::WebState* web_state) {
   DCHECK(web_state);
-  scoped_refptr<web::CertificatePolicyCache> policy_cache =
-      web::BrowserState::GetCertificatePolicyCache(
-          web_state->GetBrowserState());
+  DCHECK_CURRENTLY_ON(web::WebThread::UI);
   // 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.webState);
-  }
+// Populates the certificate policy cache based on the WebStates of |tab_model|.
+void RestoreCertificatePolicyCacheFromModel(
+    const scoped_refptr<web::CertificatePolicyCache>& policy_cache,
+    TabModel* tab_model) {
+  DCHECK_CURRENTLY_ON(web::WebThread::UI);
+  for (Tab* tab in tab_model)
+    UpdateCertificatePolicyCacheFromWebState(policy_cache, tab.webState);
 }
 
-// Scrubs the certificate policy cache of all the certificate policies except
-// those for the current entries of the given tabs.
+// Scrubs the certificate policy cache of all certificates policies except
+// those for the current entries in |tab_model|.
 void CleanCertificatePolicyCache(
-    scoped_refptr<web::CertificatePolicyCache> policy_cache,
-    NSArray* tabs) {
-  DCHECK_CURRENTLY_ON(web::WebThread::IO);
+    base::CancelableTaskTracker* task_tracker,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const scoped_refptr<web::CertificatePolicyCache>& policy_cache,
+    TabModel* tab_model) {
+  DCHECK(tab_model);
   DCHECK(policy_cache);
-  policy_cache->ClearCertificatePolicies();
-  web::WebThread::PostTask(
-      web::WebThread::UI, FROM_HERE,
-      base::Bind(&RestoreCertificatePolicyCacheFromTabs, tabs));
+  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(tab_model)));
 }
 
 }  // anonymous namespace
 
 @interface TabModelObservers : CRBProtocolObservers<TabModelObserver>
 @end
 @implementation TabModelObservers
 @end
 
 @interface TabModel ()<TabUsageRecorderDelegate> {
@@ skipping 13 matching lines @@
   int _newTabCount;
 
   // Backs up property with the same name.
   std::unique_ptr<TabUsageRecorder> _tabUsageRecorder;
   // Backs up property with the same name.
   const SessionID _sessionID;
   // Saves session's state.
   base::scoped_nsobject<SessionServiceIOS> _sessionService;
   // List of TabModelObservers.
   base::scoped_nsobject<TabModelObservers> _observers;
+
+  // Used to ensure thread-safety of the certificate policy management code.
+  base::CancelableTaskTracker _clearPoliciesTaskTracker;
 }
 
 // Session window for the contents of the tab model.
 @property(nonatomic, readonly) SessionWindowIOS* windowForSavingSession;
 
 // Returns YES if tab URL host indicates that tab is an NTP tab.
 - (BOOL)isNTPTab:(Tab*)tab;
 
 // Opens a tab at the specified URL and registers its JS-supplied window name if
 // appropriate. For certain transition types, will consult the order controller
@@ skipping 47 matching lines @@
   DCHECK([_observers empty]);
   // browserStateDestroyed should always have been called before destruction.
   DCHECK(!_browserState);
 
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   // 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.
   [self closeAllTabs];
 
+  _clearPoliciesTaskTracker.TryCancelAll();
+
   [super dealloc];
 }
 
 #pragma mark - Public methods
 
 - (Tab*)currentTab {
   return _currentTab.get();
 }
 
 - (void)setCurrentTab:(Tab*)newTab {
@@ skipping 733 matching lines @@
                 persistState:(BOOL)persistState {
   DCHECK(_browserState);
   DCHECK(window);
 
   NSArray* sessions = window.sessions;
   if (!sessions.count)
     return NO;
 
   size_t oldCount = [_tabs count];
   web::WebState::CreateParams params(_browserState);
+  scoped_refptr<web::CertificatePolicyCache> policyCache =
+      web::BrowserState::GetCertificatePolicyCache(_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:[_tabs count]];
     tab.webController.usePlaceholderOverlay = YES;
 
     // Restore the CertificatePolicyCache (note that webState is invalid after
     // passing it via move semantic to -insertTabWithWebState:atIndex:).
-    UpdateCertificatePolicyCacheFromWebState(tab.webState);
+    UpdateCertificatePolicyCacheFromWebState(policyCache, tab.webState);
   }
   DCHECK_GT([_tabs count], oldCount);
 
   // 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, [_tabs count]);
     DCHECK([self tabAtIndex:selectedIndex]);
     [self changeSelectedTabFrom:_currentTab
                              to:[self tabAtIndex:selectedIndex]
@@ skipping 26 matching lines @@
   if (webUsageEnabled_ && _currentTab) {
     [[SnapshotCache sharedInstance]
         willBeSavedGreyWhenBackgrounding:_currentTab.get().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.
-  scoped_refptr<web::CertificatePolicyCache> policy_cache =
-      web::BrowserState::GetCertificatePolicyCache(_browserState);
-  DCHECK(policy_cache);
-  web::WebThread::PostTask(
-      web::WebThread::IO, FROM_HERE,
-      base::Bind(&CleanCertificatePolicyCache, policy_cache, _tabs));
+  CleanCertificatePolicyCache(
+      &_clearPoliciesTaskTracker,
+      web::WebThread::GetTaskRunnerForThread(web::WebThread::IO),
+      web::BrowserState::GetCertificatePolicyCache(_browserState), self);
 
   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_ && _currentTab) {
@@ skipping 38 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