[iOS] Refactoring web CRWSessionController user agent code.

ios/web/navigation/crw_session_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 "ios/web/navigation/crw_session_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 96 matching lines @@
 
 - (NSString*)uniqueID;
 // Removes all entries after currentNavigationIndex_.
 - (void)clearForwardItems;
 // Discards the transient entry, if any.
 - (void)discardTransientItem;
 // Create a new autoreleased session entry.
 - (CRWSessionEntry*)sessionEntryWithURL:(const GURL&)url
                                referrer:(const web::Referrer&)referrer
                              transition:(ui::PageTransition)transition
-                    useDesktopUserAgent:(BOOL)useDesktopUserAgent
                       rendererInitiated:(BOOL)rendererInitiated;

[kkhorimoto, 2017/02/17 20:51:35]

Let's update this API to use web::NavigationInitiationType rather than the
rendererInitiated BOOL, and just pass that directly into
NavigationItemImpl::SetNavigationInitiationType() so we can avoid the
uneccessary enum => bool => enum conversion.

[liaoyuke, 2017/02/17 22:15:40]

Done.

 // Returns YES if the PageTransition for the underlying navigationItem at
 // |index| in |entries_| has ui::PAGE_TRANSITION_IS_REDIRECT_MASK.
 - (BOOL)isRedirectTransitionForItemAtIndex:(NSInteger)index;
 // Returns a NavigationItemList containing the NavigationItems from |entries|.
 - (web::NavigationItemList)itemListForEntryList:(NSArray*)entries;
 @end
 
 @implementation CRWSessionController
 
 @synthesize tabId = _tabId;
@@ skipping 182 matching lines @@
 }
 
 // See NavigationController::GetVisibleEntry for the motivation for this
 // distinction.
 - (CRWSessionEntry*)visibleEntry {
   if (_transientEntry)
     return _transientEntry.get();
   // Only return the pending_entry for new (non-history), browser-initiated
   // navigations in order to prevent URL spoof attacks.
   web::NavigationItemImpl* pendingItem = [_pendingEntry navigationItemImpl];
-  bool safeToShowPending = pendingItem &&
-                           !pendingItem->is_renderer_initiated() &&
+  bool safeToShowPending = pendingItem && !pendingItem->IsRendererInitiated() &&
                            _pendingItemIndex == -1;
   if (safeToShowPending) {
     return _pendingEntry.get();
   }
   return [self lastCommittedEntry];
 }
 
 - (CRWSessionEntry*)pendingEntry {
   return _pendingEntry.get();
 }
@@ skipping 27 matching lines @@
   // Note: CRWSessionController currently has the responsibility to distinguish
   // between new navigations and history stack navigation, hence the inclusion
   // of specific transiton type logic here, in order to make it reliable with
   // real-world observed behavior.
   // TODO(crbug.com/676129): Fix the way changes are detected/reported elsewhere
   // in the web layer so that this hack can be removed.
   // Remove the workaround code from -presentSafeBrowsingWarningForResource:.
   CRWSessionEntry* currentEntry = self.currentEntry;
   if (currentEntry) {
     web::NavigationItem* item = [currentEntry navigationItem];
-    if (item->GetURL() == url &&
-        (!PageTransitionCoreTypeIs(trans, ui::PAGE_TRANSITION_FORM_SUBMIT) ||
-         PageTransitionCoreTypeIs(item->GetTransitionType(),
-                                  ui::PAGE_TRANSITION_FORM_SUBMIT))) {
+
+    BOOL hasSameURL = item->GetURL() == url;
+    BOOL isPendingTransitionFormSubmit =
+        PageTransitionCoreTypeIs(trans, ui::PAGE_TRANSITION_FORM_SUBMIT);
+    BOOL isCurrentTransitionFormSubmit = PageTransitionCoreTypeIs(
+        item->GetTransitionType(), ui::PAGE_TRANSITION_FORM_SUBMIT);
+    BOOL shouldCreatePendingItem =
+        !hasSameURL ||
+        (isPendingTransitionFormSubmit && !isCurrentTransitionFormSubmit);
+
+    if (!shouldCreatePendingItem) {
       // Send the notification anyway, to preserve old behavior. It's unknown
       // whether anything currently relies on this, but since both this whole
       // hack and the content facade will both be going away, it's not worth
       // trying to unwind.
       if (_navigationManager && _navigationManager->GetFacadeDelegate()) {
         _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
       }
       return;
     }
   }
 
-  BOOL useDesktopUserAgent =
-      _useDesktopUserAgentForNextPendingItem ||
-      (self.currentEntry.navigationItem &&
-       self.currentEntry.navigationItem->IsOverridingUserAgent());
-  _useDesktopUserAgentForNextPendingItem = NO;
   _pendingEntry.reset([self sessionEntryWithURL:url
                                        referrer:ref
                                      transition:trans
-                            useDesktopUserAgent:useDesktopUserAgent
                               rendererInitiated:rendererInitiated]);
 
   if (_navigationManager && _navigationManager->GetFacadeDelegate()) {
     _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
   }
 }
 
 - (void)updatePendingItem:(const GURL&)url {
   // If there is no pending entry, navigation is probably happening within the
   // session history. Don't modify the entry list.
@@ skipping 73 matching lines @@
   if (_navigationManager && item)
     _navigationManager->OnNavigationItemCommitted();
   DCHECK_EQ(_pendingItemIndex, -1);
 }
 
 - (void)addTransientItemWithURL:(const GURL&)URL {
   _transientEntry.reset([self
       sessionEntryWithURL:URL
                  referrer:web::Referrer()
                transition:ui::PAGE_TRANSITION_CLIENT_REDIRECT
-      useDesktopUserAgent:NO
         rendererInitiated:NO]);
 
   web::NavigationItem* navigationItem = [_transientEntry navigationItem];
   DCHECK(navigationItem);
   navigationItem->SetTimestamp(
       _timeSmoother.GetSmoothedTime(base::Time::Now()));
 }
 
 - (void)pushNewItemWithURL:(const GURL&)URL
                stateObject:(NSString*)stateObject
                 transition:(ui::PageTransition)transition {
   DCHECK(![self pendingEntry]);
   DCHECK([self currentEntry]);
-  web::NavigationItem* item = [self currentEntry].navigationItem;
-  CHECK(
-      web::history_state_util::IsHistoryStateChangeValid(item->GetURL(), URL));
-  web::Referrer referrer(item->GetURL(), web::ReferrerPolicyDefault);
-  bool overrideUserAgent =
-      self.currentEntry.navigationItem->IsOverridingUserAgent();
+  web::NavigationItem* currentItem = [self currentEntry].navigationItem;
+  CHECK(web::history_state_util::IsHistoryStateChangeValid(
+      currentItem->GetURL(), URL));
+  web::Referrer referrer(currentItem->GetURL(), web::ReferrerPolicyDefault);
+
   base::scoped_nsobject<CRWSessionEntry> pushedEntry([self
       sessionEntryWithURL:URL
                  referrer:referrer
                transition:transition
-      useDesktopUserAgent:overrideUserAgent
         rendererInitiated:NO]);
+
   web::NavigationItemImpl* pushedItem = [pushedEntry navigationItemImpl];
+  pushedItem->SetIsOverridingUserAgent(currentItem->IsOverridingUserAgent());
   pushedItem->SetSerializedStateObject(stateObject);
   pushedItem->SetIsCreatedFromPushState(true);
   web::SSLStatus& sslStatus = [self currentEntry].navigationItem->GetSSL();
   pushedEntry.get().navigationItem->GetSSL() = sslStatus;
 
   [self clearForwardItems];
   // Add the new entry at the end.
   [_entries addObject:pushedEntry];
   _previousNavigationIndex = _currentNavigationIndex;
   self.currentNavigationIndex = [_entries count] - 1;
@@ skipping 148 matching lines @@
 
   NSInteger index = _currentNavigationIndex;
   // This will return the first session entry if all other entries are
   // redirects, regardless of the transition state of the first entry.
   while (index > 0 && [self isRedirectTransitionForItemAtIndex:index]) {
     --index;
   }
   return [_entries objectAtIndex:index];
 }
 
-- (void)useDesktopUserAgentForNextPendingItem {
-  if (_pendingEntry)
-    [_pendingEntry navigationItem]->SetIsOverridingUserAgent(true);
-  else
-    _useDesktopUserAgentForNextPendingItem = YES;
-}
-
 - (NSInteger)indexOfItem:(const web::NavigationItem*)item {
   web::NavigationItemList items = self.items;
   for (NSInteger i = 0; i < static_cast<NSInteger>(items.size()); ++i) {
     if (items[i] == item)
       return i;
   }
   return NSNotFound;
 }
 
 #pragma mark -
 #pragma mark Private methods
 
 - (NSString*)uniqueID {
   CFUUIDRef uuidRef = CFUUIDCreate(NULL);
   CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef);
   CFRelease(uuidRef);
 
   NSString* uuid =
       [NSString stringWithString:base::mac::ObjCCastStrict<NSString>(
                                      CFBridgingRelease(uuidStringRef))];
   return uuid;
 }
 
 - (CRWSessionEntry*)sessionEntryWithURL:(const GURL&)url
                                referrer:(const web::Referrer&)referrer
                              transition:(ui::PageTransition)transition
-                    useDesktopUserAgent:(BOOL)useDesktopUserAgent
                       rendererInitiated:(BOOL)rendererInitiated {
   GURL loaded_url(url);
   BOOL urlWasRewritten = NO;
   if (_navigationManager) {
     std::unique_ptr<std::vector<web::BrowserURLRewriter::URLRewriter>>
         transientRewriters = _navigationManager->GetTransientURLRewriters();
     if (transientRewriters) {
       urlWasRewritten = web::BrowserURLRewriter::RewriteURLWithWriters(
           &loaded_url, _browserState, *transientRewriters.get());
     }
   }
   if (!urlWasRewritten) {
     web::BrowserURLRewriter::GetInstance()->RewriteURLIfNecessary(
         &loaded_url, _browserState);
   }
+
   std::unique_ptr<web::NavigationItemImpl> item(new web::NavigationItemImpl());
   item->SetOriginalRequestURL(loaded_url);
   item->SetURL(loaded_url);
   item->SetReferrer(referrer);
   item->SetTransitionType(transition);
-  item->SetIsOverridingUserAgent(useDesktopUserAgent);
-  item->set_is_renderer_initiated(rendererInitiated);
+  item->SetIsRendererInitiated(rendererInitiated);
   return [[CRWSessionEntry alloc] initWithNavigationItem:std::move(item)];
 }
 
 - (BOOL)isRedirectTransitionForItemAtIndex:(NSInteger)index {
   ui::PageTransition transition =
       [_entries[index] navigationItem]->GetTransitionType();
   return (transition & ui::PAGE_TRANSITION_IS_REDIRECT_MASK) ? YES : NO;
 }
 
 - (web::NavigationItemList)itemListForEntryList:(NSArray*)entries {
   web::NavigationItemList list(entries.count);
   for (size_t index = 0; index < entries.count; ++index)
     list[index] = [entries[index] navigationItem];
   return list;
 }
 
 @end