Re-sync ios/web with downstream version

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 <algorithm>
 #include <vector>
 
 #include "base/format_macros.h"
@@ skipping 166 matching lines @@
     _browserState = browserState;
 
     // Create entries array from list of navigations.
     _entries = [[NSMutableArray alloc] initWithCapacity:scoped_items.size()];
     std::vector<web::NavigationItem*> items;
     scoped_items.release(&items);
 
     for (size_t i = 0; i < items.size(); ++i) {
       scoped_ptr<web::NavigationItem> item(items[i]);
       base::scoped_nsobject<CRWSessionEntry> entry(
-          [[CRWSessionEntry alloc] initWithNavigationItem:item.Pass() index:i]);
+          [[CRWSessionEntry alloc] initWithNavigationItem:item.Pass()]);
       [_entries addObject:entry];
     }
     _currentNavigationIndex = currentIndex;
     // Prior to M34, 0 was used as "no index" instead of -1; adjust for that.
     if (![_entries count])
       _currentNavigationIndex = -1;
     if (_currentNavigationIndex >= static_cast<NSInteger>(items.size())) {
       _currentNavigationIndex = static_cast<NSInteger>(items.size()) - 1;
     }
     _previousNavigationIndex = -1;
@@ skipping 121 matching lines @@
 
 // See NavigationController::GetVisibleEntry for the motivation for this
 // distinction.
 - (CRWSessionEntry*)visibleEntry {
   if (_transientEntry)
     return _transientEntry.get();
   // Only return the pending_entry for:
   //   (a) new (non-history), browser-initiated navigations, and
   //   (b) pending unsafe navigations (while showing the interstitial)
   // in order to prevent URL spoof attacks.
-  web::NavigationItemImpl* pendingItemImpl =
-      static_cast<web::NavigationItemImpl*>([_pendingEntry navigationItem]);
-  if (_pendingEntry &&
-      (!pendingItemImpl->is_renderer_initiated() ||
-       pendingItemImpl->IsUnsafe())) {
+  web::NavigationItemImpl* pendingItem = [_pendingEntry navigationItemImpl];
+  if (pendingItem &&
+      (!pendingItem->is_renderer_initiated() || pendingItem->IsUnsafe())) {
     return _pendingEntry.get();
   }
   return [self lastCommittedEntry];
 }
 
 - (CRWSessionEntry*)pendingEntry {
   return _pendingEntry.get();
 }
 
 - (CRWSessionEntry*)transientEntry {
@@ skipping 46 matching lines @@
       // 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 = _useDesktopUserAgentForNextPendingEntry ||
-      self.currentEntry.useDesktopUserAgent;
+  BOOL useDesktopUserAgent =
+      _useDesktopUserAgentForNextPendingEntry ||
+      (self.currentEntry.navigationItem &&
+       self.currentEntry.navigationItem->IsOverridingUserAgent());
   _useDesktopUserAgentForNextPendingEntry = NO;
   _pendingEntry.reset([[self sessionEntryWithURL:url
                                         referrer:ref
                                       transition:trans
                              useDesktopUserAgent:useDesktopUserAgent
                                rendererInitiated:rendererInitiated] retain]);
 
   if (_navigationManager && _navigationManager->GetFacadeDelegate()) {
     _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
   }
 }
 
 - (void)updatePendingEntry:(const GURL&)url {
   [self discardTransientEntry];
 
   // If there is no pending entry, navigation is probably happening within the
   // session history. Don't modify the entry list.
   if (!_pendingEntry)
     return;
-  web::NavigationItem* item = [_pendingEntry navigationItem];
+
+  web::NavigationItemImpl* item = [_pendingEntry navigationItemImpl];
   if (url != item->GetURL()) {
     item->SetURL(url);
     item->SetVirtualURL(url);
     // Since updates are caused by page redirects, they are renderer-initiated.
-    web::NavigationItemImpl* pendingItemImpl =
-        static_cast<web::NavigationItemImpl*>([_pendingEntry navigationItem]);
-    pendingItemImpl->set_is_renderer_initiated(true);
+    item->set_is_renderer_initiated(true);
     // Redirects (3xx response code), or client side navigation must change
     // POST requests to GETs.
-    [_pendingEntry setPOSTData:nil];
-    [_pendingEntry resetHTTPHeaders];
+    item->SetPostData(nil);
+    item->ResetHttpRequestHeaders();
   }
 
   // This should probably not be sent if the URLs matched, but that's what was
   // done before, so preserve behavior in case something relies on it.
   if (_navigationManager && _navigationManager->GetFacadeDelegate()) {
     _navigationManager->GetFacadeDelegate()->OnNavigationItemPending();
   }
 }
 
 - (void)clearForwardEntries {
@@ skipping 22 matching lines @@
 
 - (void)commitPendingEntry {
   if (_pendingEntry) {
     [self clearForwardEntries];
     // Add the new entry at the end.
     [_entries addObject:_pendingEntry];
     _previousNavigationIndex = _currentNavigationIndex;
     _currentNavigationIndex = [_entries count] - 1;
     // Once an entry is committed it's not renderer-initiated any more. (Matches
     // the implementation in NavigationController.)
-    web::NavigationItemImpl* pendingItemImpl =
-        static_cast<web::NavigationItemImpl*>([_pendingEntry navigationItem]);
-    pendingItemImpl->ResetForCommit();
+    [_pendingEntry navigationItemImpl]->ResetForCommit();
     _pendingEntry.reset();
   }
 
   CRWSessionEntry* currentEntry = self.currentEntry;
   web::NavigationItem* item = currentEntry.navigationItem;
   // Update the navigation timestamp now that it's actually happened.
   if (item)
     item->SetTimestamp(_timeSmoother.GetSmoothedTime(base::Time::Now()));
 
   if (_navigationManager && item)
@@ skipping 31 matching lines @@
     _navigationManager->OnNavigationItemChanged();
 }
 
 - (void)pushNewEntryWithURL:(const GURL&)url
                 stateObject:(NSString*)stateObject {
   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();
   base::scoped_nsobject<CRWSessionEntry> pushedEntry(
       [[self sessionEntryWithURL:url
                         referrer:referrer
                       transition:ui::PAGE_TRANSITION_LINK
-             useDesktopUserAgent:self.currentEntry.useDesktopUserAgent
+             useDesktopUserAgent:overrideUserAgent
                rendererInitiated:NO] retain]);
-  pushedEntry.get().serializedStateObject = stateObject;
-  pushedEntry.get().createdFromPushState = YES;
+  web::NavigationItemImpl* pushedItem = [pushedEntry navigationItemImpl];
+  pushedItem->SetSerializedStateObject(stateObject);
+  pushedItem->SetIsCreatedFromPushState(true);
   web::SSLStatus& sslStatus = [self currentEntry].navigationItem->GetSSL();
   pushedEntry.get().navigationItem->GetSSL() = sslStatus;
 
   [self clearForwardEntries];
   // Add the new entry at the end.
   [_entries addObject:pushedEntry];
   _previousNavigationIndex = _currentNavigationIndex;
   _currentNavigationIndex = [_entries count] - 1;
 
   if (_navigationManager)
     _navigationManager->OnNavigationItemCommitted();
 }
 
 - (void)updateCurrentEntryWithURL:(const GURL&)url
                       stateObject:(NSString*)stateObject {
   DCHECK(!_transientEntry);
   CRWSessionEntry* currentEntry = self.currentEntry;
+  web::NavigationItemImpl* currentItem = self.currentEntry.navigationItemImpl;
+  currentItem->SetURL(url);
+  currentItem->SetSerializedStateObject(stateObject);
   currentEntry.navigationItem->SetURL(url);
-  currentEntry.serializedStateObject = stateObject;
   // If the change is to a committed entry, notify interested parties.
   if (currentEntry != self.pendingEntry && _navigationManager)
     _navigationManager->OnNavigationItemChanged();
 }
 
 - (void)discardNonCommittedEntries {
   [self discardTransientEntry];
   _pendingEntry.reset();
 }
 
@@ skipping 235 matching lines @@
   if (firstEntry == secondEntry)
     return NO;
   NSUInteger firstIndex = [_entries indexOfObject:firstEntry];
   NSUInteger secondIndex = [_entries indexOfObject:secondEntry];
   if (firstIndex == NSNotFound || secondIndex == NSNotFound)
     return NO;
   NSUInteger startIndex = firstIndex < secondIndex ? firstIndex : secondIndex;
   NSUInteger endIndex = firstIndex < secondIndex ? secondIndex : firstIndex;
 
   for (NSUInteger i = startIndex + 1; i <= endIndex; i++) {
-    CRWSessionEntry* entry = [_entries objectAtIndex:i];
+    web::NavigationItemImpl* item = [_entries[i] navigationItemImpl];
     // Every entry in the sequence has to be created from a pushState() call.
-    if (!entry.createdFromPushState)
+    if (!item->IsCreatedFromPushState())
       return NO;
     // Every entry in the sequence has to have a URL that could have been
     // created from a pushState() call.
     if (!web::history_state_util::IsHistoryStateChangeValid(
-            firstEntry.navigationItem->GetURL(),
-            entry.navigationItem->GetURL()))
+            firstEntry.navigationItem->GetURL(), item->GetURL()))
       return NO;
   }
   return YES;
 }
 
 - (CRWSessionEntry*)lastUserEntry {
   if (![_entries count])
     return nil;
 
   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 transitionForIndex:index] &
          ui::PAGE_TRANSITION_IS_REDIRECT_MASK) {
     --index;
   }
   return [_entries objectAtIndex:index];
 }
 
 - (void)useDesktopUserAgentForNextPendingEntry {
   if (_pendingEntry)
-    [_pendingEntry setUseDesktopUserAgent:YES];
+    [_pendingEntry navigationItem]->SetIsOverridingUserAgent(true);
   else
     _useDesktopUserAgentForNextPendingEntry = YES;
 }
 
 #pragma mark -
 #pragma mark Private methods
 
 - (NSString*)uniqueID {
   CFUUIDRef uuidRef = CFUUIDCreate(NULL);
   CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef);
   CFRelease(uuidRef);
   NSString* uuid = [NSString stringWithString:(NSString*)uuidStringRef];
   CFRelease(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);
   web::BrowserURLRewriter::GetInstance()->RewriteURLIfNecessary(&loaded_url,
                                                                 _browserState);
-  return [[[CRWSessionEntry alloc] initWithUrl:loaded_url
-                                      referrer:referrer
-                                    transition:transition
-                           useDesktopUserAgent:useDesktopUserAgent
-                             rendererInitiated:rendererInitiated] autorelease];
+  scoped_ptr<web::NavigationItemImpl> item(new web::NavigationItemImpl());
+  item->SetURL(loaded_url);
+  item->SetReferrer(referrer);
+  item->SetTransitionType(transition);
+  item->SetIsOverridingUserAgent(useDesktopUserAgent);
+  item->set_is_renderer_initiated(rendererInitiated);
+  return [[CRWSessionEntry alloc] initWithNavigationItem:item.Pass()];
 }
 
 @end