Remove usage of Tab's |url| property from Tab.

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 572 matching lines @@
   parentTabModel_ = model;
 
   if (parentTabModel_.syncedWindowDelegate) {
     IOSChromeSessionTabHelper::FromWebState(self.webState)
         ->SetWindowID(model.sessionID);
   }
 }
 
 - (NSString*)description {
   return [NSString stringWithFormat:@"%p ... %@ - %s", self, self.title,
-                                    self.url.spec().c_str()];
+                                    self.visibleURL.spec().c_str()];

[kkhorimoto, 2017/04/14 21:05:16]

It seems to make the most sense to use the URL that would be displayed in the
omnibox.

 }
 
 - (CRWWebController*)webController {
   return webStateImpl_ ? webStateImpl_->GetWebController() : nil;
 }
 
 - (id<TabDialogDelegate>)dialogDelegate {
   return dialogDelegate_;
 }
 
@@ skipping 54 matching lines @@
   DCHECK([self navigationManager]);
   web::NavigationItem* item = [self navigationManager]->GetLastCommittedItem();
   if (!item)
     return nil;
   base::string16 pageTitle = item->GetTitle();
   return pageTitle.empty() ? nil : base::SysUTF16ToNSString(pageTitle);
 }
 
 - (NSString*)urlDisplayString {
   base::string16 urlText = url_formatter::FormatUrl(
-      self.url, url_formatter::kFormatUrlOmitNothing, net::UnescapeRule::SPACES,
-      nullptr, nullptr, nullptr);
+      self.visibleURL, url_formatter::kFormatUrlOmitNothing,

[kkhorimoto, 2017/04/14 21:05:16]

It seems to make the most sense to use the URL that would be displayed in the
omnibox.

+      net::UnescapeRule::SPACES, nullptr, nullptr, nullptr);
   return base::SysUTF16ToNSString(urlText);
 }
 
 - (NSString*)tabId {
   if (tabId_)
     return tabId_.get();
 
   DCHECK(self.webState);
   web::SerializableUserDataManager* userDataManager =
       web::SerializableUserDataManager::FromWebState(self.webState);
   NSString* tabId = base::mac::ObjCCast<NSString>(
       userDataManager->GetValueForSerializationKey(kTabIDKey));
 
   if (!tabId || ![tabId length]) {
     tabId = [[NSUUID UUID] UUIDString];
     userDataManager->AddSerializableData(tabId, kTabIDKey);
   }
 
   tabId_.reset([tabId copy]);
   return tabId_.get();
 }
 
 - (web::WebState*)webState {
   return webStateImpl_;
 }
 
 - (void)fetchFavicon {
-  const GURL& url = self.url;
+  const GURL& url = self.visibleURL;

[kkhorimoto, 2017/04/14 21:05:16]

Since favicon fetching occurs during a load, we should be fetching the favicon
for the page that is being loaded.

   if (!url.is_valid())
     return;
 
   favicon::FaviconDriver* faviconDriver =
       favicon::WebFaviconDriver::FromWebState(self.webState);
   if (faviconDriver) {
     faviconDriver->FetchFavicon(url);
   }
 }
 
@@ skipping 178 matching lines @@
   // Don't update the history if current entry has no title.
   NSString* title = [self title];
   if (![title length] ||
       [title isEqualToString:l10n_util::GetNSString(IDS_DEFAULT_TAB_TITLE)])
     return;
 
   history::HistoryService* historyService =
       ios::HistoryServiceFactory::GetForBrowserState(
           browserState_, ServiceAccessType::IMPLICIT_ACCESS);
   DCHECK(historyService);
-  historyService->SetPageTitle(self.url, base::SysNSStringToUTF16(title));
+  historyService->SetPageTitle(self.lastCommittedURL,
+                               base::SysNSStringToUTF16(title));

[kkhorimoto, 2017/04/14 21:05:16]

|title| is fetched via WebState::GetTitle(), which uses the last committed URL.

 }
 
 - (void)addCurrentEntryToHistoryDB {
   DCHECK([self navigationManager]->GetVisibleItem());
   // If incognito, don't update history.
   if (browserState_->IsOffTheRecord())
     return;
 
   web::NavigationItem* item = [self navigationManager]->GetVisibleItem();
 
@@ skipping 264 matching lines @@
       U2FController_.reset([[U2FController alloc] init]);
     }
 
     DCHECK([self navigationManager]);
     GURL origin =
         [self navigationManager]->GetLastCommittedItem()->GetURL().GetOrigin();
 
     // Compose u2f-x-callback URL and update urlToOpen.
     finalURL = [U2FController_ XCallbackFromRequestURL:finalURL
                                              originURL:origin
-                                                tabURL:self.url
+                                                tabURL:self.lastCommittedURL

[kkhorimoto, 2017/04/14 21:05:16]

If an external URL is being opened by a page, then we want the xcallback to
return to the page that is opening the URL.  Since a navigation needs to be
committed before opening a URL, we should use the last committed here.

                                                  tabID:self.tabId];
 
     if (!finalURL.is_valid()) {
       return NO;
     }
   }
 
   if ([externalAppLauncher_ openURL:finalURL linkClicked:linkClicked]) {
     // Clears pending navigation history after successfully launching the
     // external app.
@@ skipping 87 matching lines @@
       postNotificationName:kTabIsShowingExportableNotificationForCrashReporting
                     object:self];
   // Try to generate a filename by first looking at |content_disposition_|, then
   // at the last component of |self.url| and if both of these fail use the
   // default filename "document".
   std::string contentDisposition;
   if (headers)
     headers->GetNormalizedHeader("content-disposition", &contentDisposition);
   std::string defaultFilename =
       l10n_util::GetStringUTF8(IDS_IOS_OPEN_IN_FILE_DEFAULT_TITLE);
+  const GURL& committedURL = self.lastCommittedURL;

[kkhorimoto, 2017/04/14 21:05:16]

If a file is being opened by a page, then we want the xcallback to
return to the page that is opening the URL.  Since a navigation needs to be
committed before opening a URL, we should use the last committed here.

   base::string16 filename =
-      net::GetSuggestedFilename(self.url, contentDisposition,
+      net::GetSuggestedFilename(committedURL, contentDisposition,
                                 "",                 // referrer-charset
                                 "",                 // suggested-name
                                 "application/pdf",  // mime-type
                                 defaultFilename);
   [[self openInController]
-      enableWithDocumentURL:self.url
+      enableWithDocumentURL:committedURL
           suggestedFilename:base::SysUTF16ToNSString(filename)];
 }
 
 - (void)countMainFrameLoad {
-  if ([self isPrerenderTab] || [self url].SchemeIs(kChromeUIScheme)) {
+  if ([self isPrerenderTab] ||
+      self.lastCommittedURL.SchemeIs(kChromeUIScheme)) {

[kkhorimoto, 2017/04/14 21:05:16]

If we're counting a main frame load, then we can assume that the load has
finished and that the navigation is committed.

     return;
   }
   base::RecordAction(UserMetricsAction("MobilePageLoaded"));
 }
 
 - (void)applicationDidBecomeActive {
   if (requireReloadAfterBecomingActive_) {
     if (visible_) {
       self.navigationManager->Reload(web::ReloadType::NORMAL,
                                      false /* check_for_repost */);
@@ skipping 40 matching lines @@
 - (void)switchToReaderMode {
   DCHECK(self.view);
   [self.readerModeController switchToReaderMode];
 }
 
 - (void)loadReaderModeHTML:(NSString*)html forURL:(const GURL&)url {
   // Before changing the HTML on the current page, this checks that the URL has
   // not changed since reader mode was requested. This could happen for example
   // if the page does a late redirect itself or if the user tapped on a link and
   // triggered reader mode before the page load is detected by webState.
-  if (url == self.url)
+  if (url == self.visibleURL)

[kkhorimoto, 2017/04/14 21:05:16]

Reader mode HTML is loaded when a load is taking too long, so we should use the
visible URL to reflect the navigation that is occurring.

     [self.webController loadHTMLForCurrentURL:html];
 
   [self.readerModeController exitReaderMode];
 }
 
 #pragma mark -
 
 - (BOOL)usesDesktopUserAgent {
   if (!self.navigationManager)
     return NO;
@@ skipping 91 matching lines @@
 
   BOOL isUserNavigationEvent =
       (transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK) == 0;
   // Check for link-follow clobbers. These are changes where there is no
   // pending entry (since that means the change wasn't caused by this class),
   // and where the URL changes (to avoid counting page resurrection).
   // TODO(crbug.com/546401): Consider moving this into NavigationManager, or
   // into a NavigationManager observer callback, so it doesn't need to be
   // checked in several places.
   if (isUserNavigationEvent && !isPrerenderTab_ &&
-      ![self navigationManager]->GetPendingItem() && url != self.url) {
+      ![self navigationManager]->GetPendingItem() && url != self.visibleURL) {
     base::RecordAction(UserMetricsAction("MobileTabClobbered"));
     if ([parentTabModel_ tabUsageRecorder])
       [parentTabModel_ tabUsageRecorder]->RecordPageLoadStart(self);
   }
   if (![self navigationManager]->GetPendingItem()) {
     // Reset |isVoiceSearchResultsTab| since a new page is being navigated to.
     self.isVoiceSearchResultsTab = NO;
   }
 }
 
@@ skipping 503 matching lines @@
 
 - (TabModel*)parentTabModel {
   return parentTabModel_;
 }
 
 - (FormInputAccessoryViewController*)inputAccessoryViewController {
   return inputAccessoryViewController_.get();
 }
 
 @end