[ios] WebStateList owns all WebState it manages.

ios/chrome/browser/ui/preload_controller.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 <UIKit/UIKit.h>
 
 #include "ios/chrome/browser/ui/preload_controller.h"
 
 #include "base/ios/device_util.h"
 #include "base/logging.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/prefs/pref_service.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/pref_names.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"
 #include "ios/chrome/browser/ui/preload_controller_delegate.h"
 #include "ios/chrome/browser/ui/prerender_final_status.h"
 #import "ios/web/public/web_state/ui/crw_native_content.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "ui/base/page_transition_types.h"
 
@@ skipping 66 matching lines @@
  public:
   explicit PrefetchDelegate(PreloadController* owner) : owner_(owner) {}
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     [owner_ prefetchDidComplete:source];
   }
 
  private:
   PreloadController* owner_;  // weak
 };
 
-@implementation PreloadController
+@implementation PreloadController {
+  ios::ChromeBrowserState* browserState_;  // Weak.
+
+  // The WebState used for prerendering.
+  std::unique_ptr<web::WebState> webState_;
+
+  // The URL that is prerendered in |webState_|.  This can be different from
+  // the value returned by WebState last committed navigation item, for example
+  // in cases where there was a redirect.
+  //
+  // When choosing whether or not to use a prerendered Tab,
+  // BrowserViewController compares the URL being loaded by the omnibox with the
+  // URL of the prerendered Tab.  Comparing against the Tab's currently URL
+  // could return false negatives in cases of redirect, hence the need to store
+  // the originally prerendered URL.
+  GURL prerenderedURL_;
+
+  // The URL that is scheduled to be prerendered, its associated transition and
+  // referrer. |scheduledTransition_| and |scheduledReferrer_| are not valid
+  // when |scheduledURL_| is empty.
+  GURL scheduledURL_;
+  ui::PageTransition scheduledTransition_;
+  web::Referrer scheduledReferrer_;
+
+  // The most-recently prefetched URL, or nil if there have been no prefetched
+  // URLs.
+  GURL prefetchedURL_;
+
+  // The URLFetcher and associated delegate used to prefetch URLs. The delegate
+  // simply forwards callbacks from URLFetcher back to the PrerenderController.
+  std::unique_ptr<PrefetchDelegate> prefetcherDelegate_;
+  std::unique_ptr<net::URLFetcher> prefetcher_;
+
+  // Bridge to listen to pref changes.
+  std::unique_ptr<PrefObserverBridge> observerBridge_;
+  // Registrar for pref changes notifications.
+  PrefChangeRegistrar prefChangeRegistrar_;
+  // Observer for the WWAN setting.  Contains a valid object only if the
+  // instant setting is set to wifi-only.
+  std::unique_ptr<ConnectionTypeObserverBridge> connectionTypeObserverBridge_;
+
+  // Whether or not the preference is enabled.
+  BOOL enabled_;
+  // Whether or not prerendering is only when on wifi.
+  BOOL wifiOnly_;
+  // Whether or not the current connection is using WWAN.
+  BOOL usingWWAN_;
+
+  // Number of successful prerenders (i.e. the user viewed the prerendered page)
+  // during the lifetime of this controller.
+  int successfulPrerendersPerSessionCount_;
+
+  id<PreloadControllerDelegate> delegate_;  // weak
+}
 
 @synthesize prerenderedURL = prerenderedURL_;
 @synthesize prefetchedURL = prefetchedURL_;
 @synthesize delegate = delegate_;
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState {
   DCHECK(browserState);
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   if ((self = [super init])) {
     browserState_ = browserState;
@@ skipping 93 matching lines @@
 
 - (void)cancelPrerender {
   [self cancelPrerenderForReason:PRERENDER_FINAL_STATUS_CANCELLED];
 }
 
 - (void)cancelPrerenderForReason:(PrerenderFinalStatus)reason {
   [self removeScheduledPrerenderRequests];
   [self destroyPreviewContentsForReason:reason];
 }
 
-- (Tab*)releasePrerenderContents {
+- (std::unique_ptr<web::WebState>)releasePrerenderContents {
   successfulPrerendersPerSessionCount_++;
   UMA_HISTOGRAM_ENUMERATION(kPrerenderFinalStatusHistogramName,
                             PRERENDER_FINAL_STATUS_USED,
                             PRERENDER_FINAL_STATUS_MAX);
   [self removeScheduledPrerenderRequests];
   prerenderedURL_ = GURL();
-  [[tab_ webController] setNativeProvider:nil];
-  [tab_ setDelegate:nil];
-  return [tab_.release() autorelease];
+
+  if (webState_) {
+    Tab* tab = LegacyTabHelper::GetTabForWebState(webState_.get());
+    [[tab webController] setNativeProvider:nil];
+    [tab setDelegate:nil];
+  }
+
+  return std::move(webState_);
 }
 
 - (void)connectionTypeChanged:(net::NetworkChangeNotifier::ConnectionType)type {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   usingWWAN_ = net::NetworkChangeNotifier::IsConnectionCellular(type);
   if (wifiOnly_ && usingWWAN_)
     [self cancelPrerender];
 }
 
 - (void)onPreferenceChanged:(const std::string&)preferenceName {
@@ skipping 27 matching lines @@
 
 - (void)didReceiveMemoryWarning {
   [self cancelPrerenderForReason:PRERENDER_FINAL_STATUS_MEMORY_LIMIT_EXCEEDED];
 }
 
 #pragma mark -
 #pragma mark CRWNativeContentProvider implementation
 
 // Delegate the call to the original native provider.
 - (BOOL)hasControllerForURL:(const GURL&)url {
-  return [[tab_ webController].nativeProvider hasControllerForURL:url];
+  if (!webState_)
+    return NO;
+  Tab* tab = LegacyTabHelper::GetTabForWebState(webState_.get());
+  return [[tab webController].nativeProvider hasControllerForURL:url];
 }
 
 // Override the CRWNativeContentProvider methods to cancel any prerenders that
 // require native content.
 - (id<CRWNativeContent>)controllerForURL:(const GURL&)url
                                 webState:(web::WebState*)webState {
   [self schedulePrerenderCancel];
   return nil;
 }
 
@@ skipping 30 matching lines @@
   [self destroyPreviewContents];
   prerenderedURL_ = scheduledURL_;
   scheduledURL_ = GURL();
 
   DCHECK(prerenderedURL_.is_valid());
   if (!prerenderedURL_.is_valid()) {
     [self destroyPreviewContents];
     return;
   }
 
-  Tab* tab =
-      [Tab preloadingTabWithBrowserState:browserState_
-                                     url:prerenderedURL_
-                                referrer:scheduledReferrer_
-                              transition:scheduledTransition_
-                                provider:self
-                                  opener:nil
-                        desktopUserAgent:[delegate_ shouldUseDesktopUserAgent]
-                           configuration:^(Tab* tab) {
-                             [tab setIsPrerenderTab:YES];
-                             [tab setDelegate:self];
-                           }];
+  web::WebState::CreateParams createParams(browserState_);
+  webState_ = web::WebState::Create(createParams);
+  AttachTabHelpers(webState_.get());
 
-  // Create and set up the prerender.
-  tab_.reset([tab retain]);
+  Tab* tab = LegacyTabHelper::GetTabForWebState(webState_.get());
+  DCHECK(tab);
+
+  if ([delegate_ shouldUseDesktopUserAgent])
+    [tab enableDesktopUserAgent];
+
+  [[tab webController] setNativeProvider:self];
+  [[tab webController] setWebUsageEnabled:YES];
+  [tab setIsPrerenderTab:YES];
+  [tab setDelegate:self];
+
+  web::NavigationManager::WebLoadParams loadParams(prerenderedURL_);
+  loadParams.referrer = scheduledReferrer_;
+  loadParams.transition_type = scheduledTransition_;
+  [[tab webController] loadWithParams:loadParams];
 
   // Trigger the page to start loading.
-  [tab_ view];
+  [tab view];
 }
 
 - (const GURL)urlToPrefetchURL:(const GURL&)url {
   GURL::Replacements replacements;
 
   // Add prefetch indicator to query params.
   std::string query = url.query();
   if (!query.empty()) {
     query.append("&");
   }
@@ skipping 18 matching lines @@
         << "Prefetching URL got response code " << source->GetResponseCode();
   }
   prefetcher_.reset();
 }
 
 - (void)destroyPreviewContents {
   [self destroyPreviewContentsForReason:PRERENDER_FINAL_STATUS_CANCELLED];
 }
 
 - (void)destroyPreviewContentsForReason:(PrerenderFinalStatus)reason {
-  if (!tab_.get())
+  if (!webState_)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(kPrerenderFinalStatusHistogramName, reason,
                             PRERENDER_FINAL_STATUS_MAX);
-  [[tab_ webController] setNativeProvider:nil];
-  [tab_ setDelegate:nil];
-  [tab_ close];
-  tab_.reset();
+
+  Tab* tab = LegacyTabHelper::GetTabForWebState(webState_.get());
+  [[tab webController] setNativeProvider:nil];
+  [tab setDelegate:nil];
+  webState_.reset();
+
   prerenderedURL_ = GURL();
 }
 
 - (void)schedulePrerenderCancel {
   // TODO(rohitrao): Instead of cancelling the prerender, should we mark it as
   // failed instead?  That way, subsequent prerender requests for the same URL
   // will not kick off new prerenders.  b/5944421
   [self removeScheduledPrerenderRequests];
   [self performSelector:@selector(cancelPrerender) withObject:nil afterDelay:0];
 }
 
 - (void)removeScheduledPrerenderRequests {
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
   scheduledURL_ = GURL();
 }
 
 #pragma mark - TabDelegate
 
 - (void)discardPrerender {
   [self schedulePrerenderCancel];
 }
 
 @end