[ios] Removed webDidFinishWithURL:loadSuccess: from CRWWebDelegate.

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 124 matching lines @@
 #import "ios/web/public/navigation_manager.h"
 #include "ios/web/public/referrer.h"
 #include "ios/web/public/ssl_status.h"
 #include "ios/web/public/url_scheme_util.h"
 #include "ios/web/public/url_util.h"
 #include "ios/web/public/web_client.h"
 #import "ios/web/public/web_state/crw_web_user_interface_delegate.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #import "ios/web/public/web_state/ui/crw_generic_content_view.h"
 #include "ios/web/public/web_state/web_state.h"
+#import "ios/web/public/web_state/web_state_observer_bridge.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/web_state_impl.h"
 #include "net/base/escape.h"
 #include "net/base/filename_util.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/http_response_headers.h"
@@ skipping 38 matching lines @@
   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 ()<BlockedPopupHandlerDelegate,
+                  CRWWebStateObserver,
                   CRWWebUserInterfaceDelegate,
                   FindInPageControllerDelegate,
                   ReaderModeControllerDelegate> {
   TabModel* parentTabModel_;               // weak
   ios::ChromeBrowserState* browserState_;  // weak
 
   base::scoped_nsobject<OpenInController> openInController_;
   base::WeakNSProtocol<id<PassKitDialogProvider>> passKitDialogProvider_;
   // TODO(crbug.com/546213): Move this out of Tab, probably to native app
   // launcher since that's the only thing that uses it.
@@ skipping 88 matching lines @@
 
   // 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_;
 
+  // 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_;
 
   // C++ bridge that receives notifications from the FaviconDriver.
   std::unique_ptr<FaviconDriverObserverBridge> faviconDriverObserverBridge_;
 
@@ skipping 230 matching lines @@
   DCHECK(webState);
   self = [super init];
   if (self) {
     propertyReleaser_Tab_.Init(self, [Tab class]);
     tabHistoryContext_.reset(new TabHistoryContext());
     parentTabModel_ = parentModel;
     browserState_ =
         ios::ChromeBrowserState::FromBrowserState(webState->GetBrowserState());
 
     webStateImpl_.reset(static_cast<web::WebStateImpl*>(webState.release()));
+    webStateObserver_.reset(
+        new web::WebStateObserverBridge(webStateImpl_.get(), self));
+
     [self.webController setDelegate:self];
     [self.webController setUIDelegate:self];
 
     NSString* sessionID = [self currentSessionID];
     DCHECK(sessionID);
     snapshotManager_.reset([[SnapshotManager alloc] init]);
 
     webControllerSnapshotHelper_.reset([[WebControllerSnapshotHelper alloc]
         initWithSnapshotManager:snapshotManager_
                             tab:self]);
@@ skipping 1096 matching lines @@
 
 - (void)evaluateU2FResultFromURL:(const GURL&)URL {
   DCHECK(U2FController_);
   [U2FController_ evaluateU2FResultFromU2FURL:URL webState:self.webState];
 }
 
 - (NSString*)currentSessionID {
   return [self tabId];
 }
 
-#pragma mark - WebDelegate protocol methods.
+#pragma mark - CRWWebDelegate and CRWWebStateObserver protocol methods.
 
 - (CRWWebController*)webPageOrderedOpen:(const GURL&)URL
                                referrer:(const web::Referrer&)referrer
                              windowName:(NSString*)windowName
                            inBackground:(BOOL)inBackground {
   // Prerendered Tabs cannot open child windows.
   // TODO(crbug.com/661673): Should we kill prerendering in this case?
   if (!parentTabModel_)
     return nil;
   if (!inBackground)
@@ skipping 199 matching lines @@
   NSString* urlString = base::SysUTF8ToNSString(currentUrl.spec());
   if ([urlString length]) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kTabUrlStartedLoadingNotificationForCrashReporting
                       object:self
                     userInfo:[NSDictionary dictionaryWithObject:urlString
                                                          forKey:kTabUrlKey]];
   }
 }
 
-// Called when the page finishes loading, with the URL and a boolean indicating
-// if the page was successfully loaded.
-- (void)webDidFinishWithURL:(const GURL&)url loadSuccess:(BOOL)loadSuccess {
+- (void)webStateDidLoadPage:(web::WebState*)webState
+                withSuccess:(BOOL)loadSuccess {
   DCHECK(self.webController.loadPhase == web::PAGE_LOADED);
 
   // Cancel prerendering if response is "application/octet-stream". It can be a
   // video file which should not be played from preload tab (crbug.com/436813).
   if (isPrerenderTab_ &&
       self.webState->GetContentsMimeType() == "application/octet-stream") {
     [delegate_ discardPrerender];
   }
 
   bool wasPost = false;
   if (self.currentSessionEntry)
     wasPost = self.currentSessionEntry.navigationItem->HasPostData();
+  GURL lastCommittedURL = self.webState->GetLastCommittedURL();
   if (loadSuccess)
-    [autoReloadBridge_ loadFinishedForURL:url wasPost:wasPost];
+    [autoReloadBridge_ loadFinishedForURL:lastCommittedURL wasPost:wasPost];
   else
-    [autoReloadBridge_ loadFailedForURL:url wasPost:wasPost];
+    [autoReloadBridge_ loadFailedForURL:lastCommittedURL wasPost:wasPost];
   [webControllerSnapshotHelper_ setSnapshotCoalescingEnabled:YES];
   if (!loadSuccess) {
     [fullScreenController_ disableFullScreen];
   }
   [self recordInterfaceOrientation];
   navigation_metrics::OriginsSeenService* originsSeenService =
       IOSChromeOriginsSeenServiceFactory::GetForBrowserState(self.browserState);
-  bool already_seen = originsSeenService->Insert(url::Origin::Origin(url));
+  bool alreadySeen =
+      originsSeenService->Insert(url::Origin::Origin(lastCommittedURL));
   navigation_metrics::RecordMainFrameNavigation(
-      url, true, self.browserState->IsOffTheRecord(), already_seen);
+      lastCommittedURL, true, self.browserState->IsOffTheRecord(), alreadySeen);
 
   if (loadSuccess) {
     scoped_refptr<net::HttpResponseHeaders> headers =
         self.webStateImpl->GetHttpResponseHeaders();
     [self handleExportableFile:headers.get()];
   }
 
   [metricsClientManager_ pageLoadCompleted];
   [parentTabModel_ notifyTabChanged:self];
 
@@ skipping 10 matching lines @@
                                      kTabModelPageLoadSuccess, nil]];
   }
   [[OmniboxGeolocationController sharedInstance]
       finishPageLoadForTab:self
                loadSuccess:loadSuccess];
 
   // Always take snapshots on iPad if the tab switcher is enabled.
   // If the tab switcher is not enabled, don't take snapshot of chrome scheme
   // pages.
   BOOL takeSnapshotOnIpad =
-      IsIPadIdiom() && (experimental_flags::IsTabSwitcherEnabled() ||
-                        !web::GetWebClient()->IsAppSpecificURL(url));
+      IsIPadIdiom() &&
+      (experimental_flags::IsTabSwitcherEnabled() ||
+       !web::GetWebClient()->IsAppSpecificURL(lastCommittedURL));
   // Always take snapshot on iPhone.
   BOOL takeSnapshot = !IsIPadIdiom() || takeSnapshotOnIpad;
   if (loadSuccess && takeSnapshot) {
     [self updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
   }
   [webControllerSnapshotHelper_ setSnapshotCoalescingEnabled:NO];
 }
 
 - (void)webLoadCancelled:(const GURL&)url {
   // When a load is cancelled, this is the maximum that a page will ever load.
@@ skipping 432 matching lines @@
 
 - (void)replaceWebStateImpl:(std::unique_ptr<web::WebStateImpl>)webState {
   // Stop observing the old InfoBarManager and FaviconDriver since they will
   // be deleted with the old web controller.
   [self setShouldObserveInfoBarManager:NO];
   [self setShouldObserveFaviconChanges:NO];
   [self.webController setDelegate:nil];
   // Set the new web state.
   webStateImpl_.reset(webState.release());
   [self.webController setDelegate:self];
+  webStateObserver_.reset(
+      new web::WebStateObserverBridge(webStateImpl_.get(), self));
   // SessionTabHelper comes first because it sets up the tab ID, and other
   // helpers may rely on that.
   IOSChromeSessionTabHelper::CreateForWebState(webStateImpl_.get());
   IOSChromeSyncedTabDelegate::CreateForWebState(webStateImpl_.get());
   // Start observing the new web controller's InfoBarManager and FaviconDriver.
   [self setShouldObserveInfoBarManager:YES];
   [self setShouldObserveFaviconChanges:YES];
   findInPageController_.reset();
 }
 
 - (void)replaceExternalAppLauncher:(id)externalAppLauncher {
   externalAppLauncher_.reset([externalAppLauncher retain]);
 }
 
 - (TabModel*)parentTabModel {
   return parentTabModel_;
 }
 
 - (FormInputAccessoryViewController*)inputAccessoryViewController {
   return inputAccessoryViewController_.get();
 }
 
 @end