Renamed WasWithinSamePage to WasWithinSameDocument.

content/renderer/render_frame_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.
 
 #include "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 3609 matching lines @@
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   const WebURLResponse& web_url_response = frame->dataSource()->response();
   WebURLResponseExtraDataImpl* extra_data =
       GetExtraDataFromResponse(web_url_response);
   // Only update the PreviewsState and effective connection type states for new
   // main frame documents. Subframes inherit from the main frame and should not
   // change at commit time.
-  if (is_main_frame_ && !navigation_state->WasWithinSamePage()) {
+  if (is_main_frame_ && !navigation_state->WasWithinSameDocument()) {
     previews_state_ =
         extra_data ? extra_data->previews_state() : PREVIEWS_OFF;
 
     // Set lite pages off if a lite page was not loaded for the main frame.
     if (web_url_response
             .httpHeaderField(
                 WebString::fromUTF8(kChromeProxyContentTransformHeader))
             .utf8() != kChromeProxyLitePageDirective) {
       previews_state_ &= ~(SERVER_LITE_PAGE_ON);
     }
 
     if (extra_data) {
       effective_connection_type_ =
           EffectiveConnectionTypeToWebEffectiveConnectionType(
               extra_data->effective_connection_type());
     }
   }
 
   if (proxy_routing_id_ != MSG_ROUTING_NONE) {
     // If this is a provisional frame associated with a proxy (i.e., a frame
     // created for a remote-to-local navigation), swap it into the frame tree
     // now.
     if (!SwapIn())
       return;
   }
 
-  // For new page navigations, the browser process needs to be notified of the
-  // first paint of that page, so it can cancel the timer that waits for it.
-  if (is_main_frame_ && !navigation_state->WasWithinSamePage()) {
+  // For navigations that change the document, the browser process needs to be
+  // notified of the first paint of that page, so it can cancel the timer that
+  // waits for it.
+  if (is_main_frame_ && !navigation_state->WasWithinSameDocument()) {
     GetRenderWidget()->IncrementContentSourceId();
     render_view_->QueueMessage(
         new ViewHostMsg_DidFirstPaintAfterLoad(render_view_->routing_id_),
         MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
   }
 
   // When we perform a new navigation, we need to update the last committed
   // session history entry with state for the page we are leaving. Do this
   // before updating the current history item.
   SendUpdateState();
@@ skipping 30 matching lines @@
         !request_params.intended_as_new_entry) {
       // This is a successful session history navigation!
       render_view_->history_list_offset_ =
           request_params.pending_history_list_offset;
     }
   }
 
   for (auto& observer : render_view_->observers_)
     observer.DidCommitProvisionalLoad(frame, is_new_navigation);
   for (auto& observer : observers_) {
-    observer.DidCommitProvisionalLoad(is_new_navigation,
-                                      navigation_state->WasWithinSamePage());
+    observer.DidCommitProvisionalLoad(
+        is_new_navigation, navigation_state->WasWithinSameDocument());
   }
 
   if (!frame->parent()) {  // Only for top frames.
     RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
     if (render_thread_impl) {  // Can be NULL in tests.
       render_thread_impl->histogram_customizer()->
           RenderViewNavigatedToHost(GURL(GetLoadingUrl()).host(),
                                     RenderView::GetRenderViewCount());
       // The scheduler isn't interested in history inert commits unless they
       // are reloads.
@@ skipping 317 matching lines @@
     blink::WebHistoryCommitType commit_type,
     bool content_initiated) {
   TRACE_EVENT1("navigation,rail", "RenderFrameImpl::didNavigateWithinPage",
                "id", routing_id_);
   DCHECK_EQ(frame_, frame);
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   UpdateNavigationState(document_state, true /* was_within_same_page */,
                         content_initiated);
   static_cast<NavigationStateImpl*>(document_state->navigation_state())
-      ->set_was_within_same_page(true);
+      ->set_was_within_same_document(true);
 
   didCommitProvisionalLoad(frame, item, commit_type);
 }
 
 void RenderFrameImpl::didUpdateCurrentHistoryItem() {
   render_view_->StartNavStateSyncTimerIfNecessary(this);
 }
 
 void RenderFrameImpl::didChangeThemeColor() {
   if (frame_->parent())
@@ skipping 785 matching lines @@
   // We need to track the RenderViewHost routing_id because of downstream
   // dependencies (crbug.com/392171 DownloadRequestHandle, SaveFileManager,
   // ResourceDispatcherHostImpl, MediaStreamUIProxy,
   // SpeechRecognitionDispatcherHost and possibly others). They look up the view
   // based on the ID stored in the resource requests. Once those dependencies
   // are unwound or moved to RenderFrameHost (crbug.com/304341) we can move the
   // client to be based on the routing_id of the RenderFrameHost.
   params.render_view_routing_id = render_view_->routing_id();
   params.socket_address.set_host(response.remoteIPAddress().utf8());
   params.socket_address.set_port(response.remotePort());
-  params.was_within_same_page = navigation_state->WasWithinSamePage();
+  params.was_within_same_document = navigation_state->WasWithinSameDocument();
 
   WebDocument frame_document = frame->document();
   // Set the origin of the frame.  This will be replicated to the corresponding
   // RenderFrameProxies in other processes.
   WebSecurityOrigin frame_origin = frame_document.getSecurityOrigin();
   params.origin = frame_origin;
 
   params.insecure_request_policy = frame->getInsecureRequestPolicy();
 
   params.has_potentially_trustworthy_unique_origin =
@@ skipping 142 matching lines @@
              .allow_universal_access_from_file_urls) {
       base::debug::SetCrashKeyValue("origin_mismatch_url", params.url.spec());
       base::debug::SetCrashKeyValue("origin_mismatch_origin",
                                     params.origin.Serialize());
       base::debug::SetCrashKeyValue("origin_mismatch_transition",
                                     base::IntToString(params.transition));
       base::debug::SetCrashKeyValue("origin_mismatch_redirects",
                                     base::IntToString(params.redirects.size()));
       base::debug::SetCrashKeyValue(
           "origin_mismatch_same_page",
-          base::IntToString(params.was_within_same_page));
+          base::IntToString(params.was_within_same_document));
       CHECK(params.origin.IsSamePhysicalOriginWith(url::Origin(params.url)))
           << " url:" << params.url << " origin:" << params.origin;
     }
   }
 
   // This message needs to be sent before any of allowScripts(),
   // allowImages(), allowPlugins() is called for the new page, so that when
   // these functions send a ViewHostMsg_ContentBlocked message, it arrives
   // after the FrameHostMsg_DidCommitProvisionalLoad message.
   Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
@@ skipping 1860 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content