[ios] WebStateList owns all WebState it manages.

ios/chrome/browser/tabs/tab.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.h"
 
 #import <CoreLocation/CoreLocation.h>
 #import <UIKit/UIKit.h>
 
 #include <utility>
@@ skipping 152 matching lines @@
 
 namespace {
 class TabHistoryContext;
 class FaviconDriverObserverBridge;
 class TabInfoBarObserver;
 
 // The key under which the Tab ID is stored in the WebState's serializable user
 // data.
 NSString* const kTabIDKey = @"TabID";
 
-// 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";
-
 // Name of histogram for recording the state of the tab when the renderer is
 // terminated.
 const char kRendererTerminationStateHistogram[] =
     "Tab.StateAtRendererTermination";
 
 // Referrer used for clicks on article suggestions on the NTP.
 const char kChromeContentSuggestionsReferrer[] =
     "https://www.googleapis.com/auth/chrome-content-suggestions";
 
 // Enum corresponding to UMA's TabForegroundState, for
 // Tab.StateAtRendererTermination. Must be kept in sync with the UMA enum.
 enum class RendererTerminationTabState {
   // These two values are for when the app is in the foreground.
   FOREGROUND_TAB_FOREGROUND_APP = 0,
   BACKGROUND_TAB_FOREGROUND_APP,
   // These are for when the app is in the background.
   FOREGROUND_TAB_BACKGROUND_APP,
   BACKGROUND_TAB_BACKGROUND_APP,
   TERMINATION_TAB_STATE_COUNT
 };
 }  // namespace
 
 @interface Tab ()<CRWWebStateObserver,
+                  CRWWebControllerObserver,
                   FindInPageControllerDelegate,
                   ReaderModeControllerDelegate> {
   TabModel* parentTabModel_;               // weak
   ios::ChromeBrowserState* browserState_;  // weak
 
   base::scoped_nsobject<OpenInController> openInController_;
   base::WeakNSProtocol<id<PassKitDialogProvider>> passKitDialogProvider_;
 
   // Whether or not this tab is currently being displayed.
   BOOL visible_;
@@ skipping 74 matching lines @@
   base::scoped_nsobject<WebControllerSnapshotHelper>
       webControllerSnapshotHelper_;
 
   // Handles support for window.print JavaScript calls.
   std::unique_ptr<PrintObserver> printObserver_;
 
   // AutoReloadBridge for this tab.
   base::scoped_nsobject<AutoReloadBridge> autoReloadBridge_;
 
   // WebStateImpl for this tab.
-  std::unique_ptr<web::WebStateImpl> webStateImpl_;
+  web::WebStateImpl* webStateImpl_;
 
   // Allows Tab to conform CRWWebStateDelegate protocol.
   std::unique_ptr<web::WebStateObserverBridge> webStateObserver_;
 
   // Context used by history to scope the lifetime of navigation entry
   // references to Tab.
   std::unique_ptr<TabHistoryContext> tabHistoryContext_;
 
   // The controller for everything related to reader mode.
   base::scoped_nsobject<ReaderModeController> readerModeController_;
@@ skipping 162 matching lines @@
 
 @synthesize browserState = browserState_;
 @synthesize useGreyImageCache = useGreyImageCache_;
 @synthesize isPrerenderTab = isPrerenderTab_;
 @synthesize isLinkLoadingPrerenderTab = isLinkLoadingPrerenderTab_;
 @synthesize isVoiceSearchResultsTab = isVoiceSearchResultsTab_;
 @synthesize delegate = delegate_;
 @synthesize tabSnapshottingDelegate = tabSnapshottingDelegate_;
 @synthesize tabHeadersDelegate = tabHeadersDelegate_;
 
-- (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
-                              opener:(Tab*)opener
-                         openedByDOM:(BOOL)openedByDOM
-                               model:(TabModel*)parentModel {
-  web::WebState::CreateParams params(browserState);
-  params.created_with_opener = openedByDOM;
-  std::unique_ptr<web::WebState> webState = web::WebState::Create(params);
-  if ([opener navigationManager]) {
-    web::SerializableUserDataManager* userDataManager =
-        web::SerializableUserDataManager::FromWebState(webState.get());
-    userDataManager->AddSerializableData(opener.tabId, kOpenerIDKey);
-    userDataManager->AddSerializableData(
-        @([opener navigationManager]->GetLastCommittedItemIndex()),
-        kOpenerNavigationIndexKey);
-  }
-
-  return [self initWithWebState:std::move(webState) model:parentModel];
-}
-
-- (instancetype)initWithWebState:(std::unique_ptr<web::WebState>)webState
-                           model:(TabModel*)parentModel {
-  return [self initWithWebState:std::move(webState)
-                          model:parentModel
-               attachTabHelpers:YES];
-}
-
-- (instancetype)initWithWebState:(std::unique_ptr<web::WebState>)webState
-                           model:(TabModel*)parentModel
-                attachTabHelpers:(BOOL)attachTabHelpers {
+- (instancetype)initWithWebState:(web::WebState*)webState {
   DCHECK(webState);
   self = [super init];
   if (self) {
     propertyReleaser_Tab_.Init(self, [Tab class]);
-    tabHistoryContext_.reset(new TabHistoryContext());
-    parentTabModel_ = parentModel;
+
+    // TODO(crbug.com/620465): Tab should only use public API of WebState.
+    // Remove this cast once this is the case.
+    webStateImpl_ = static_cast<web::WebStateImpl*>(webState);
     browserState_ =
         ios::ChromeBrowserState::FromBrowserState(webState->GetBrowserState());
 
-    webStateImpl_.reset(static_cast<web::WebStateImpl*>(webState.release()));
-    webStateObserver_.reset(
-        new web::WebStateObserverBridge(self.webState, self));
+    tabHistoryContext_ = base::MakeUnique<TabHistoryContext>();
+    webStateObserver_ =
+        base::MakeUnique<web::WebStateObserverBridge>(webState, self);
+
     [self updateLastVisitedTimestamp];
-
-    // Do not respect |attachTabHelpers| as this tab helper is required for
-    // proper conversion from WebState to Tab.
-    LegacyTabHelper::CreateForWebState(self.webState, self);
-
-    [self.webController setDelegate:self];
+    [[self webController] addObserver:self];
+    [[self webController] setDelegate:self];
 
     snapshotManager_.reset([[SnapshotManager alloc] init]);
     webControllerSnapshotHelper_.reset([[WebControllerSnapshotHelper alloc]
         initWithSnapshotManager:snapshotManager_
                             tab:self]);
 
     [self initNativeAppNavigationController];
 
-    if (attachTabHelpers) {
-      AttachTabHelpers(self.webState);
-
-      tabInfoBarObserver_.reset(new TabInfoBarObserver(self));
-      tabInfoBarObserver_->SetShouldObserveInfoBarManager(true);
-
-      if (experimental_flags::IsAutoReloadEnabled()) {
-        autoReloadBridge_.reset([[AutoReloadBridge alloc] initWithTab:self]);
-      }
-      printObserver_.reset(new PrintObserver(self.webState));
-
-      base::scoped_nsprotocol<id<PasswordsUiDelegate>> passwordsUiDelegate(
-          [[PasswordsUiDelegateImpl alloc] init]);
-      passwordController_.reset([[PasswordController alloc]
-             initWithWebState:self.webState
-          passwordsUiDelegate:passwordsUiDelegate]);
-      password_manager::PasswordGenerationManager* passwordGenerationManager =
-          [passwordController_ passwordGenerationManager];
-      autofillController_.reset([[AutofillController alloc]
-               initWithBrowserState:browserState_
-          passwordGenerationManager:passwordGenerationManager
-                           webState:self.webState]);
-      suggestionController_.reset([[FormSuggestionController alloc]
-          initWithWebState:self.webState
-                 providers:[self suggestionProviders]]);
-      inputAccessoryViewController_.reset(
-          [[FormInputAccessoryViewController alloc]
-              initWithWebState:self.webState
-                     providers:[self accessoryViewProviders]]);
-
-      [self setShouldObserveFaviconChanges:YES];
-
-      if (parentModel && parentModel.syncedWindowDelegate) {
-        IOSChromeSessionTabHelper::FromWebState(self.webState)
-            ->SetWindowID(parentModel.sessionID);
-      }
-
-      // Create the ReaderModeController immediately so it can register for
-      // WebState changes.
-      if (experimental_flags::IsReaderModeEnabled()) {
-        readerModeController_.reset([[ReaderModeController alloc]
-            initWithWebState:self.webState
-                    delegate:self]);
-      }
-    }
-
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(applicationDidBecomeActive)
                name:UIApplicationDidBecomeActiveNotification
              object:nil];
   }
   return self;
 }
 
+- (void)attachTabHelpers {
+  tabInfoBarObserver_.reset(new TabInfoBarObserver(self));
+  tabInfoBarObserver_->SetShouldObserveInfoBarManager(true);
+
+  if (experimental_flags::IsAutoReloadEnabled()) {
+    autoReloadBridge_.reset([[AutoReloadBridge alloc] initWithTab:self]);
+  }
+  printObserver_ = base::MakeUnique<PrintObserver>(self.webState);
+
+  base::scoped_nsprotocol<id<PasswordsUiDelegate>> passwordsUiDelegate(
+      [[PasswordsUiDelegateImpl alloc] init]);
+  passwordController_.reset([[PasswordController alloc]
+         initWithWebState:self.webState
+      passwordsUiDelegate:passwordsUiDelegate]);
+  password_manager::PasswordGenerationManager* passwordGenerationManager =
+      [passwordController_ passwordGenerationManager];
+  autofillController_.reset([[AutofillController alloc]
+           initWithBrowserState:browserState_
+      passwordGenerationManager:passwordGenerationManager
+                       webState:self.webState]);
+  suggestionController_.reset([[FormSuggestionController alloc]
+      initWithWebState:self.webState
+             providers:[self suggestionProviders]]);
+  inputAccessoryViewController_.reset([[FormInputAccessoryViewController alloc]
+      initWithWebState:self.webState
+             providers:[self accessoryViewProviders]]);
+
+  [self setShouldObserveFaviconChanges:YES];
+
+  // Create the ReaderModeController immediately so it can register for
+  // WebState changes.
+  if (experimental_flags::IsReaderModeEnabled()) {
+    readerModeController_.reset([[ReaderModeController alloc]
+        initWithWebState:self.webState
+                delegate:self]);
+  }
+}
+
 - (NSArray*)accessoryViewProviders {
   NSMutableArray* providers = [NSMutableArray array];
   id<FormInputAccessoryViewProvider> provider =
       [passwordController_ accessoryViewProvider];
   if (provider)
     [providers addObject:provider];
   [providers addObject:[suggestionController_ accessoryViewProvider]];
   return providers;
 }
 
 - (NSArray*)suggestionProviders {
   NSMutableArray* providers = [NSMutableArray array];
   [providers addObject:[passwordController_ suggestionProvider]];
   [providers addObject:[autofillController_ suggestionProvider]];
   return providers;
 }
 
 - (id<FindInPageControllerDelegate>)findInPageControllerDelegate {
   return self;
 }
 
-+ (Tab*)preloadingTabWithBrowserState:(ios::ChromeBrowserState*)browserState
-                                  url:(const GURL&)URL
-                             referrer:(const web::Referrer&)referrer
-                           transition:(ui::PageTransition)transition
-                             provider:(id<CRWNativeContentProvider>)provider
-                               opener:(Tab*)opener
-                     desktopUserAgent:(BOOL)desktopUserAgent
-                        configuration:(void (^)(Tab*))configuration {
-  Tab* tab = [[[Tab alloc] initWithBrowserState:browserState
-                                         opener:opener
-                                    openedByDOM:NO
-                                          model:nil] autorelease];
-  if (desktopUserAgent)
-    [tab enableDesktopUserAgent];
-  [[tab webController] setNativeProvider:provider];
-  [[tab webController] setWebUsageEnabled:YES];
-
-  if (configuration)
-    configuration(tab);
-
-  web::NavigationManager::WebLoadParams params(URL);
-  params.transition_type = transition;
-  params.referrer = referrer;
-  [[tab webController] loadWithParams:params];
-
-  return tab;
-}
-
-- (void)dealloc {
-  DCHECK([NSThread isMainThread]);
-  // Note that -[CRWWebController close] has already been called, so nothing
-  // significant should be done with it in this method.
-  DCHECK_NE(self.webController.delegate, self);
-  [super dealloc];
-}
 
 - (void)setParentTabModel:(TabModel*)model {
   DCHECK(!model || !parentTabModel_);
   parentTabModel_ = model;
 
   if (parentTabModel_.syncedWindowDelegate) {
     IOSChromeSessionTabHelper::FromWebState(self.webState)
         ->SetWindowID(model.sessionID);
   }
 }
@@ skipping 82 matching lines @@
 
   if (!tabId || ![tabId length]) {
     tabId = [[NSUUID UUID] UUIDString];
     userDataManager->AddSerializableData(tabId, kTabIDKey);
   }
 
   tabId_.reset([tabId copy]);
   return tabId_.get();
 }
 
-- (NSString*)openerID {
-  DCHECK(self.webState);
-  web::SerializableUserDataManager* userDataManager =
-      web::SerializableUserDataManager::FromWebState(self.webState);
-  id<NSCoding> openerID =
-      userDataManager->GetValueForSerializationKey(kOpenerIDKey);
-  return base::mac::ObjCCastStrict<NSString>(openerID);
-}
-
-- (NSInteger)openerNavigationIndex {
-  DCHECK(self.webState);
-  web::SerializableUserDataManager* userDataManager =
-      web::SerializableUserDataManager::FromWebState(self.webState);
-  id<NSCoding> openerNavigationIndex =
-      userDataManager->GetValueForSerializationKey(kOpenerNavigationIndexKey);
-  if (!openerNavigationIndex)
-    return -1;
-  return base::mac::ObjCCastStrict<NSNumber>(openerNavigationIndex)
-      .integerValue;
-}
-
 - (web::WebState*)webState {
-  return webStateImpl_.get();
+  return webStateImpl_;
 }
 
 - (void)fetchFavicon {
   const GURL& url = self.url;
   if (!url.is_valid())
     return;
 
   favicon::FaviconDriver* faviconDriver =
       favicon::WebFaviconDriver::FromWebState(self.webState);
   if (faviconDriver) {
@@ skipping 346 matching lines @@
 // Equivalent to the user pressing 'stop', or a window.stop() command.
 - (void)stopLoading {
   [self.webController stopLoading];
 }
 
 // Halt the tab, which amounts to halting its webController.
 - (void)terminateNetworkActivity {
   [self.webController terminateNetworkActivity];
 }
 
-// This can't be done in dealloc in case someone holds an extra strong
-// reference to the Tab, which would cause the close sequence to fire at a
-// random time.
-- (void)close {
+- (void)webStateDestroyed:(web::WebState*)webState {
+  DCHECK_EQ(webStateImpl_, webState);
   self.fullScreenControllerDelegate = nil;
   self.overscrollActionsControllerDelegate = nil;
   self.passKitDialogProvider = nil;
   self.snapshotOverlayProvider = nil;
 
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [passwordController_ detach];
   passwordController_.reset();
   tabInfoBarObserver_.reset();
 
   faviconDriverObserverBridge_.reset();
   [openInController_ detachFromWebController];
   openInController_.reset();
   [autofillController_ detachFromWebState];
   [suggestionController_ detachFromWebState];
   if (fullScreenController_)
     [self.webController removeObserver:fullScreenController_];

[rohitrao (ping after 24h), 2017/04/03 17:49:34]

Over IM, you mentioned that Tab is now a WebControllerObserver because you had
to call removeObserver before webStateDestroyed.  Don't we have the same problem
here (and for the overscrollActionsController_ below)?

[sdefresne, 2017/04/04 13:47:56]

On IM I said that Tab need to be a WebControllerObserver because I have to call
-setDelegate: not -removeObserver: (i.e. CRWWebController DCHECK that delegate
is nil when -close is called but does not check that it has no observers).

So this is not a problem removing the observer at that point.

   [fullScreenController_ invalidate];
   fullScreenController_.reset();
   if (overscrollActionsController_)
     [self.webController removeObserver:overscrollActionsController_];
   [overscrollActionsController_ invalidate];
   overscrollActionsController_.reset();
   [readerModeController_ detachFromWebState];
   readerModeController_.reset();
 
   // Invalidate any snapshot stored for this session.
   DCHECK(self.tabId);
   [snapshotManager_ removeImageWithSessionID:self.tabId];
-  // Reset association with the webController.
-  [self.webController setDelegate:nil];
 
   // Cancel any queued dialogs.
   [self.dialogDelegate cancelDialogForTab:self];
 
-  // These steps must be done last, and must be done in this order; nothing
-  // involving the tab should be done after didCloseTab:, and the
-  // CRWWebController backing the tab should outlive anything done during tab
-  // closure (since -[CRWWebController close] is what begins tearing down the
-  // web/ layer, and tab closure may trigger operations that need to query the
-  // web/ layer). The scoped strong ref is because didCloseTab: is often the
-  // trigger for deallocating the tab, but that can in turn cause
-  // CRWWebController to be deallocated before its close is called.  The facade
-  // delegate should be torn down after |-didCloseTab:| so components triggered
-  // by tab closure can use the content facade, and it should be deleted before
-  // the web controller since the web controller owns the facade's backing
-  // objects. |parentTabModel_| is reset after calling |-didCloseTab:| to
-  // prevent propagating WebState notifications that happen during WebState
-  // destruction.
-  // TODO(crbug.com/546222): Fix the need for this; TabModel should be
-  // responsible for making the lifetime of Tab sane, rather than allowing Tab
-  // to drive its own destruction.
-  base::scoped_nsobject<Tab> kungFuDeathGrip([self retain]);
-  [parentTabModel_ didCloseTab:self];  // Inform parent of tab closure.
-  parentTabModel_ = nil;
-
-  // Destroy the WebState but first stop listening to WebState events (as |self|
-  // is in no state to respond to the notifications if |webStateImpl_| is null).
-  LegacyTabHelper::RemoveFromWebState(self.webState);
   webStateObserver_.reset();
-  webStateImpl_.reset();
+  webStateImpl_ = nullptr;
 }
 
 - (void)dismissModals {
   [openInController_ disable];
   [self.webController dismissModals];
 }
 
 - (void)setShouldObserveInfoBarManager:(BOOL)shouldObserveInfoBarManager {
   tabInfoBarObserver_->SetShouldObserveInfoBarManager(
       shouldObserveInfoBarManager);
@@ skipping 311 matching lines @@
 - (void)setSnapshotOverlayProvider:
     (id<SnapshotOverlayProvider>)snapshotOverlayProvider {
   snapshotOverlayProvider_.reset(snapshotOverlayProvider);
 }
 
 - (void)evaluateU2FResultFromURL:(const GURL&)URL {
   DCHECK(U2FController_);
   [U2FController_ evaluateU2FResultFromU2FURL:URL webState:self.webState];
 }
 
+#pragma mark - CRWWebControllerObserver protocol methods.
+
+- (void)webControllerWillClose:(CRWWebController*)webController {
+  DCHECK_EQ(webController, [self webController]);
+  [[self webController] removeObserver:self];
+  [[self webController] setDelegate:nil];
+}
+
 #pragma mark - CRWWebDelegate and CRWWebStateObserver protocol methods.
 
 // This method is invoked whenever the system believes the URL is about to
 // change, or immediately after any unexpected change of the URL. The apparent
 // destination URL is included in the |url| parameter.
 // Warning: because of the present design it is possible for malicious websites
 // to invoke superflous instances of this delegate with artibrary URLs.
 // Ensure there is nothing here that could be a risk to the user beyond mild
 // confusion in that event (e.g. progress bar starting unexpectedly).
 - (void)webWillAddPendingURL:(const GURL&)url
@@ skipping 541 matching lines @@
 
 - (TabModel*)parentTabModel {
   return parentTabModel_;
 }
 
 - (FormInputAccessoryViewController*)inputAccessoryViewController {
   return inputAccessoryViewController_.get();
 }
 
 @end