Remove NAVIGATION_TYPE_IN_PAGE.

content/browser/frame_host/navigation_controller_impl.cc

 // Copyright 2013 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.
 
 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  *     (http://www.torchmobile.com/)
  *
@@ skipping 842 matching lines @@
 
   // is_in_page must be computed before the entry gets committed.
   details->is_in_page = IsURLInPageNavigation(
       params.url, params.was_within_same_page, rfh);
 
   switch (details->type) {
     case NAVIGATION_TYPE_NEW_PAGE:
       RendererDidNavigateToNewPage(rfh, params, details->did_replace_entry);
       break;
     case NAVIGATION_TYPE_EXISTING_PAGE:
+      details->did_replace_entry = details->is_in_page;
       RendererDidNavigateToExistingPage(rfh, params);
       break;
     case NAVIGATION_TYPE_SAME_PAGE:
       RendererDidNavigateToSamePage(rfh, params);
       break;
-    case NAVIGATION_TYPE_IN_PAGE:
-      RendererDidNavigateInPage(rfh, params, &details->did_replace_entry);
-      break;
     case NAVIGATION_TYPE_NEW_SUBFRAME:
       RendererDidNavigateNewSubframe(rfh, params);
       break;
     case NAVIGATION_TYPE_AUTO_SUBFRAME:
       if (!RendererDidNavigateAutoSubframe(rfh, params))
         return false;
       break;
     case NAVIGATION_TYPE_NAV_IGNORE:
       // If a pending navigation was in progress, this canceled it.  We should
       // discard it and make sure it is removed from the URL bar.  After that,
@@ skipping 112 matching lines @@
     // This is a renderer-initiated navigation (nav_entry_id == 0), but didn't
     // create a new page.
 
     // Just like above in the did_create_new_entry case, it's possible to
     // scribble onto an uncommitted page. Again, there isn't any navigation
     // stuff that we can do, so ignore it here as well.
     NavigationEntry* last_committed = GetLastCommittedEntry();
     if (!last_committed)
       return NAVIGATION_TYPE_NAV_IGNORE;
 
-    if (IsURLInPageNavigation(params.url, params.was_within_same_page, rfh)) {
-      // This is history.replaceState(), which is renderer-initiated yet within
-      // the same page.
-      return NAVIGATION_TYPE_IN_PAGE;
-    } else {
-      // This is history.reload() or a client-side redirect.
-      return NAVIGATION_TYPE_EXISTING_PAGE;
-    }
+    // This is history.replaceState(), history.reload(), or a client-side
+    // redirect.
+    return NAVIGATION_TYPE_EXISTING_PAGE;
   }
 
   if (pending_entry_ && pending_entry_index_ == -1 &&
       pending_entry_->GetUniqueID() == params.nav_entry_id) {
     // In this case, we have a pending entry for a load of a new URL but Blink
     // didn't do a new navigation (params.did_create_new_entry). This happens
     // when you press enter in the URL bar to reload. We will create a pending
     // entry, but Blink will convert it to a reload since it's the same page and
     // not create a new entry for it (the user doesn't want to have a new
     // back/forward entry when they do this). Therefore we want to just ignore
@@ skipping 18 matching lines @@
   }
 
   // Now we know that the notification is for an existing page. Find that entry.
   int existing_entry_index = GetEntryIndexWithUniqueID(params.nav_entry_id);
   if (existing_entry_index == -1) {
     // The renderer has committed a navigation to an entry that no longer
     // exists. Because the renderer is showing that page, resurrect that entry.
     return NAVIGATION_TYPE_NEW_PAGE;
   }
 
-  // Any top-level navigations with the same base (minus the reference fragment)
-  // are in-page navigations. (We weeded out subframe navigations above.) Most
-  // of the time this doesn't matter since Blink doesn't tell us about subframe
-  // navigations that don't actually navigate, but it can happen when there is
-  // an encoding override (it always sends a navigation request).
-  if (IsURLInPageNavigation(params.url, params.was_within_same_page, rfh))
-    return NAVIGATION_TYPE_IN_PAGE;
-
   // Since we weeded out "new" navigations above, we know this is an existing
   // (back/forward) navigation.
   return NAVIGATION_TYPE_EXISTING_PAGE;
 }
 
 void NavigationControllerImpl::RendererDidNavigateToNewPage(
     RenderFrameHostImpl* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     bool replace_entry) {
   scoped_ptr<NavigationEntryImpl> new_entry;
@@ skipping 157 matching lines @@
   existing_entry->SetURL(params.url);
   existing_entry->SetReferrer(params.referrer);
 
   // The page may have been requested with a different HTTP method.
   existing_entry->SetHasPostData(params.is_post);
   existing_entry->SetPostID(params.post_id);
 
   DiscardNonCommittedEntries();
 }
 
-void NavigationControllerImpl::RendererDidNavigateInPage(

[Charlie Reis, 2015/07/07 00:07:15]

Wow, this is all handled by RendererDidNavigateToExistingPage already, isn't it?
 I would have expected there to be some difference to account for, but the extra
tasks that one does don't seem to be an issue.  Having one fewer case to account
for is nice.

[Avi (use Gerrit), 2015/07/07 04:38:16]

Yes. The only real difference is setting the did_replace_entry but I moved that
to RDN.

Less identical code, check.

-    RenderFrameHostImpl* rfh,
-    const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
-    bool* did_replace_entry) {
-  DCHECK(!rfh->GetParent()) <<
-      "Blink should only tell us about in-page navs for the main frame.";
-
-  NavigationEntryImpl* existing_entry;
-  if (params.nav_entry_id) {
-    // This is a browser-initiated history navigation across an existing
-    // fragment navigation or pushState-created entry.
-    existing_entry = GetEntryWithUniqueID(params.nav_entry_id);
-  } else {
-    // This is renderer-initiated. The only kinds of renderer-initated
-    // navigations that are IN_PAGE are history.replaceState, which lands us at
-    // the last committed entry.
-    existing_entry = GetLastCommittedEntry();
-  }
-  DCHECK(existing_entry);
-
-  // Reference fragment navigation. We're guaranteed to have the last_committed
-  // entry and it will be the same page as the new navigation (minus the
-  // reference fragments, of course).  We'll update the URL of the existing
-  // entry without pruning the forward history.
-  existing_entry->set_page_type(params.url_is_unreachable ? PAGE_TYPE_ERROR
-                                                          : PAGE_TYPE_NORMAL);
-  existing_entry->SetURL(params.url);
-  if (existing_entry->update_virtual_url_with_url())
-    UpdateVirtualURLToURL(existing_entry, params.url);
-
-  existing_entry->SetHasPostData(params.is_post);
-  existing_entry->SetPostID(params.post_id);
-
-  // This replaces the existing entry since the page ID didn't change.
-  *did_replace_entry = true;
-
-  DiscardNonCommittedEntriesInternal();
-
-  // If a transient entry was removed, the indices might have changed, so we
-  // have to query the entry index again.
-  last_committed_entry_index_ = GetIndexOfEntry(existing_entry);
-}
-
 void NavigationControllerImpl::RendererDidNavigateNewSubframe(
     RenderFrameHostImpl* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
   if (!ui::PageTransitionCoreTypeIs(params.transition,
                                     ui::PAGE_TRANSITION_MANUAL_SUBFRAME)) {
     // There was a comment here that said, "This is not user-initiated. Ignore."
     // But this makes no sense; non-user-initiated navigations should be
     // determined to be of type NAVIGATION_TYPE_AUTO_SUBFRAME and sent to
     // RendererDidNavigateAutoSubframe below.
     //
@@ skipping 768 matching lines @@
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
 
 }  // namespace content