[ios] WebStateList owns all WebState it manages.

ios/chrome/browser/ui/contextual_search/contextual_search_results_view.mm

 // Copyright 2016 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.
 
 #include "ios/chrome/browser/ui/contextual_search/contextual_search_results_view.h"
 
 #include <memory>
 
 #import "base/ios/weak_nsobject.h"
 #include "base/mac/scoped_nsobject.h"
+#include "base/memory/ptr_util.h"
+#include "ios/chrome/browser/browser_state/chrome_browser_state.h"
+#import "ios/chrome/browser/tabs/legacy_tab_helper.h"
 #import "ios/chrome/browser/tabs/tab.h"
+#import "ios/chrome/browser/tabs/tab_helper_util.h"
+#import "ios/chrome/browser/tabs/tab_private.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_metrics.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_panel_view.h"
 #import "ios/chrome/browser/ui/contextual_search/contextual_search_web_state_observer.h"
 #import "ios/chrome/common/material_timing.h"
+#import "ios/shared/chrome/browser/tabs/web_state_opener.h"
 #include "ios/web/public/load_committed_details.h"
+#import "ios/web/public/serializable_user_data_manager.h"
 #import "ios/web/public/web_state/ui/crw_native_content_provider.h"
 #import "ios/web/public/web_state/ui/crw_web_view_proxy.h"
 #import "ios/web/public/web_state/ui/crw_web_view_scroll_view_proxy.h"
+#import "ios/web/public/web_state/web_state.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 
 namespace {
 enum SearchResultsViewVisibility { OFFSCREEN, PRELOAD, VISIBLE };
 }
 
 @interface ContextualSearchResultsView ()<ContextualSearchWebStateDelegate,
                                           CRWNativeContentProvider>
 
 // Can the search results be scrolled currently?
 @property(nonatomic, assign, getter=isScrollEnabled) BOOL scrollEnabled;
 @end
 
 @implementation ContextualSearchResultsView {
   base::WeakNSProtocol<id<ContextualSearchTabPromoter>> _promoter;
   base::WeakNSProtocol<id<ContextualSearchPreloadChecker>> _preloadChecker;
   std::unique_ptr<ContextualSearchWebStateObserver> _webStateObserver;
 
-  // Tab that loads the search results.
-  base::scoped_nsobject<Tab> _tab;
+  // WebState that loads the search results.
+  std::unique_ptr<web::WebState> _webState;
+  std::unique_ptr<WebStateOpener> _webStateOpener;
 
   // Access to the search tab's web view proxy.
   base::scoped_nsprotocol<id<CRWWebViewProxy>> _webViewProxy;
 
   BOOL _loaded;
   BOOL _displayed;
   BOOL _loadingError;
   BOOL _waitingForInitialSearchTabLoad;
   BOOL _loadInProgress;
   BOOL _shouldScroll;
@@ skipping 49 matching lines @@
 - (void)setPreloadChecker:(id<ContextualSearchPreloadChecker>)preloadChecker {
   _preloadChecker.reset(preloadChecker);
 }
 
 - (BOOL)contentVisible {
   return _loaded && _visibility == VISIBLE;
 }
 
 - (void)setActive:(BOOL)active {
   if (active) {
-    // Start watching the embedded Tab's web activity.
-    _webStateObserver->ObserveWebState([_tab webState]);
-    [[_tab webController] setShouldSuppressDialogs:NO];
-    _webViewProxy.reset([[[_tab webController] webViewProxy] retain]);
-    [[_webViewProxy scrollViewProxy] setBounces:NO];
+    if (_webState) {
+      Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+      // Start watching the embedded Tab's web activity.
+      _webStateObserver->ObserveWebState(_webState.get());
+      [[tab webController] setShouldSuppressDialogs:NO];
+      _webViewProxy.reset([[[tab webController] webViewProxy] retain]);
+      [[_webViewProxy scrollViewProxy] setBounces:NO];
+    }
   } else {
     // Stop watching the embedded Tab's web activity.
     _webStateObserver->ObserveWebState(nullptr);
     _webViewProxy.reset(nil);
   }
 
   _active = active;
 }
 
 #pragma mark - public methods
 
 - (void)scrollToTopAnimated:(BOOL)animated {
   [[_webViewProxy scrollViewProxy] setBounces:YES];
   // Scroll the search tab's view to the top.
   [[_webViewProxy scrollViewProxy] setContentOffset:CGPointZero
                                            animated:animated];
 }
 
 - (void)createTabForSearch:(GURL)url preloadEnabled:(BOOL)preloadEnabled {
   DCHECK(self.opener);
-  if (_tab)
+  if (_webState)
     [self cancelLoad];
 
-  void (^searchTabConfiguration)(Tab*) = ^(Tab* tab) {
-    [tab setIsLinkLoadingPrerenderTab:YES];
-    [[tab webController] setDelegate:tab];
-  };
+  _webStateOpener = base::MakeUnique<WebStateOpener>(self.opener.webState);
+  web::WebState::CreateParams createParams(self.opener.browserState);
+  _webState = web::WebState::Create(createParams);
 
-  ui::PageTransition transition = ui::PAGE_TRANSITION_FROM_ADDRESS_BAR;
-  Tab* tab = [Tab preloadingTabWithBrowserState:self.opener.browserState
-                                            url:url
-                                       referrer:web::Referrer()
-                                     transition:transition
-                                       provider:self
-                                         opener:self.opener
-                               desktopUserAgent:false
-                                  configuration:searchTabConfiguration];
-  _tab.reset([tab retain]);
+  AttachTabHelpers(_webState.get());
+  Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+  DCHECK(tab);
+
+  [[tab webController] setNativeProvider:self];
+  [[tab webController] setWebUsageEnabled:YES];
+  [tab setIsLinkLoadingPrerenderTab:YES];
+
+  web::NavigationManager::WebLoadParams loadParams(url);
+  loadParams.transition_type = ui::PAGE_TRANSITION_FROM_ADDRESS_BAR;
+  [[tab webController] loadWithParams:loadParams];
+
   // Don't actually start the page load yet -- that happens in -loadTab
 
   _preloadEnabled = preloadEnabled;
   [self loadPendingSearchIfPossible];
 }
 
-- (Tab*)releaseTab {
+- (std::unique_ptr<web::WebState>)releaseWebState {
   [self disconnectTab];
   // Allow the search tab to be sized by autoresizing mask again.
-  [[_tab view] setTranslatesAutoresizingMaskIntoConstraints:YES];
-  return [_tab.release() autorelease];
+  if (_webState) {
+    Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+    [[tab view] setTranslatesAutoresizingMaskIntoConstraints:YES];
+  }
+  return std::move(_webState);
+}
+
+- (WebStateOpener)webStateOpener {
+  DCHECK(_webStateOpener);
+  return *_webStateOpener;
 }
 
 - (void)recordFinishedSearchChained:(BOOL)chained {
   base::TimeDelta duration = base::Time::Now() - _loadStartTime;
   ContextualSearch::RecordDuration(self.contentVisible, chained, duration);
 }
 
 #pragma mark - private methods
 
 - (void)disconnectTab {
-  [[_tab view] removeFromSuperview];
-  [[_tab webController] setNativeProvider:nil];
+  if (_webState) {
+    Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+    [[tab view] removeFromSuperview];
+    [[tab webController] setNativeProvider:nil];
+  }
   self.active = NO;
   _webViewProxy.reset();
 }
 
 - (void)cancelLoad {
   [self disconnectTab];
   _loadInProgress = NO;
   _loaded = NO;
-  [_tab close];
-  _tab.reset();
+  _webState.reset();
 }
 
 - (void)loadPendingSearchIfPossible {
   // If the search tab hasn't been created, or if it's already loaded, no-op.
-  if (!_tab.get() || _loadInProgress || self.active || _visibility == OFFSCREEN)
+  if (!_webState || _loadInProgress || self.active || _visibility == OFFSCREEN)
     return;
 
   // If this view is in a position where loading would be "preloading", check
   // if that's allowed.
   if (_visibility == PRELOAD &&
       !([_preloadChecker canPreloadSearchResults] && _preloadEnabled)) {
     return;
   }
   [self loadTab];
 }
 
 - (void)loadTab {
-  DCHECK(_tab.get());
+  DCHECK(_webState);
   // Start observing the search tab.
   self.active = YES;
   // TODO(crbug.com/546223): See if |_waitingForInitialSearchTabLoad| and
   // |_loadInProgress| can be consolidated.
   _waitingForInitialSearchTabLoad = YES;
   // Mark the start of the time for the search.
   _loadStartTime = base::Time::Now();
   // Start the load by asking for the tab's view, but making it hidden.
-  [_tab view].hidden = YES;
-  [self addSubview:[_tab view]];
+  Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+  [tab view].hidden = YES;
+  [self addSubview:[tab view]];
   _loadInProgress = YES;
 }
 
 - (void)displayTab {
-  [_tab view].frame = self.bounds;
+  DCHECK(_webState);
+  Tab* tab = LegacyTabHelper::GetTabForWebState(_webState.get());
+  [tab view].frame = self.bounds;
   _loadInProgress = NO;
 
   void (^insertTab)(void) = ^{
-    [_tab view].hidden = NO;
+    [tab view].hidden = NO;
     self.scrollEnabled = _shouldScroll;
   };
 
   if (_visibility == VISIBLE) {
     // Fade it in quickly.
     UIViewAnimationOptions options =
         UIViewAnimationOptionTransitionCrossDissolve;
     [UIView cr_transitionWithView:self
                          duration:ios::material::kDuration2
                             curve:ios::material::CurveEaseInOut
@@ skipping 122 matching lines @@
                                                        withError:error
                                                           isPost:isPost];
 
   if ([errorController respondsToSelector:@selector(setScrollEnabled:)]) {
     [errorController setScrollEnabled:NO];
   }
   return errorController;
 }
 
 @end