Drop replacesCurrentHistoryItem, NavigationType

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 284 matching lines @@
 using blink::WebFrameLoadType;
 using blink::WebFrameSerializer;
 using blink::WebFrameSerializerClient;
 using blink::WebHistoryItem;
 using blink::WebHTTPBody;
 using blink::WebLocalFrame;
 using blink::WebMediaPlayer;
 using blink::WebMediaPlayerClient;
 using blink::WebMediaPlayerEncryptedMediaClient;
 using blink::WebNavigationPolicy;
-using blink::WebNavigationType;
 using blink::WebNode;
 using blink::WebPluginDocument;
 using blink::WebPluginParams;
 using blink::WebPoint;
 using blink::WebPopupMenuInfo;
 using blink::WebRange;
 using blink::WebRect;
 using blink::WebReferrerPolicy;
 using blink::WebScriptSource;
 using blink::WebSearchableFormData;
@@ skipping 310 matching lines @@
   // version supported by blink. It will be passed back to the renderer in the
   // CommitNavigation IPC, and then back to the browser again in the
   // DidCommitProvisionalLoad and the DocumentLoadComplete IPCs.
   base::TimeTicks ui_timestamp =
       base::TimeTicks() +
       base::TimeDelta::FromSecondsD(info.urlRequest.uiStartTime());
   FrameMsg_UILoadMetricsReportType::Value report_type =
       static_cast<FrameMsg_UILoadMetricsReportType::Value>(
           info.urlRequest.inputPerfMetricReportPolicy());
 
+  bool is_reload = info.loadType == WebFrameLoadType::Reload ||
+                   info.loadType == WebFrameLoadType::ReloadMainResource ||
+                   info.loadType == WebFrameLoadType::ReloadBypassingCache;
   FrameMsg_Navigate_Type::Value navigation_type =
-      info.navigationType == blink::WebNavigationTypeReload
-      ? FrameMsg_Navigate_Type::RELOAD
-      : FrameMsg_Navigate_Type::NORMAL;
+      is_reload ? FrameMsg_Navigate_Type::RELOAD
+                : FrameMsg_Navigate_Type::NORMAL;
 
   const RequestExtraData* extra_data =
       static_cast<RequestExtraData*>(info.urlRequest.getExtraData());
   DCHECK(extra_data);
   return CommonNavigationParams(
       info.urlRequest.url(), referrer, extra_data->transition_type(),
-      navigation_type, true, info.replacesCurrentHistoryItem, ui_timestamp,
+      navigation_type, true,
+      info.loadType == WebFrameLoadType::ReplaceCurrentItem, ui_timestamp,
       report_type, GURL(), GURL(),
       static_cast<PreviewsState>(info.urlRequest.getPreviewsState()),
       base::TimeTicks::Now(), info.urlRequest.httpMethod().latin1(),
       GetRequestBodyForWebURLRequest(info.urlRequest));
 }
 
 media::Context3D GetSharedMainThreadContext3D(
     scoped_refptr<ui::ContextProviderCommandBuffer> provider) {
   if (!provider)
     return media::Context3D();
@@ skipping 1838 matching lines @@
   }
 #if defined(OS_CHROMEOS)
   LOG(WARNING) << "Pepper module/plugin creation failed.";
 #endif
 #endif
   return NULL;
 }
 
 void RenderFrameImpl::LoadURLExternally(const blink::WebURLRequest& request,
                                         blink::WebNavigationPolicy policy) {
-  loadURLExternally(request, policy, WebString(), false);
+  loadURLExternally(request, policy, WebString(), WebFrameLoadType::Standard);
 }
 
 void RenderFrameImpl::loadErrorPage(int reason) {
   blink::WebURLError error;
   error.unreachableURL = frame_->document().url();
   error.domain = WebString::fromUTF8(net::kErrorDomain);
   error.reason = reason;
 
   std::string error_html;
   GetContentClient()->renderer()->GetNavigationErrorStrings(
@@ skipping 748 matching lines @@
   }
 
   Send(new FrameHostMsg_DidAddMessageToConsole(
       routing_id_, static_cast<int32_t>(log_severity), message.text.utf16(),
       static_cast<int32_t>(source_line), source_name.utf16()));
 }
 
 void RenderFrameImpl::loadURLExternally(const blink::WebURLRequest& request,
                                         blink::WebNavigationPolicy policy,
                                         const blink::WebString& suggested_name,
-                                        bool should_replace_current_entry) {
+                                        WebFrameLoadType load_type) {
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame_, request));
   if (policy == blink::WebNavigationPolicyDownload) {
     FrameHostMsg_DownloadUrl_Params params;
     params.render_view_id = render_view_->GetRoutingID();
     params.render_frame_id = GetRoutingID();
     params.url = request.url();
     params.referrer = referrer;
     params.initiator_origin = request.requestorOrigin();
     params.suggested_name = suggested_name.utf16();
 
     Send(new FrameHostMsg_DownloadUrl(params));
   } else {
     OpenURL(request.url(), IsHttpPost(request),
             GetRequestBodyForWebURLRequest(request),
-            GetWebURLRequestHeaders(request), referrer, policy,
-            should_replace_current_entry, false);
+            GetWebURLRequestHeaders(request), referrer, policy, load_type);
   }
 }
 
 blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame() {
   // We will punt this navigation to the browser in decidePolicyForNavigation.
   // TODO(creis): Look into cleaning this up.
   return WebHistoryItem();
 }
 
 void RenderFrameImpl::willSendSubmitEvent(const blink::WebFormElement& form) {
@@ skipping 112 matching lines @@
           DocumentState::FromDataSource(datasource)))
     return;
 
   ServiceWorkerNetworkProvider::AttachToDocumentState(
       DocumentState::FromDataSource(datasource),
       ServiceWorkerNetworkProvider::CreateForNavigation(
           routing_id_, navigation_state->request_params(), frame,
           content_initiated));
 }
 
-void RenderFrameImpl::didStartProvisionalLoad(blink::WebLocalFrame* frame) {
-  DCHECK_EQ(frame_, frame);
-  WebDataSource* ds = frame->provisionalDataSource();
-
-  // In fast/loader/stop-provisional-loads.html, we abort the load before this
-  // callback is invoked.
-  if (!ds)
-    return;
-
+void RenderFrameImpl::didStartProvisionalLoad(WebDataSource* ds,
+                                              WebFrameLoadType type) {
   TRACE_EVENT2("navigation,benchmark,rail",
                "RenderFrameImpl::didStartProvisionalLoad", "id", routing_id_,
                "url", ds->getRequest().url().string().utf8());
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   NavigationStateImpl* navigation_state = static_cast<NavigationStateImpl*>(
       document_state->navigation_state());
-  bool is_top_most = !frame->parent();
+  bool is_top_most = !frame_->parent();
   if (is_top_most) {
     render_view_->set_navigation_gesture(
         WebUserGestureIndicator::isProcessingUserGesture() ?
             NavigationGestureUser : NavigationGestureAuto);
-  } else if (ds->replacesCurrentHistoryItem()) {
+  } else if (type == WebFrameLoadType::ReplaceCurrentItem) {
     // Subframe navigations that don't add session history items must be
     // marked with AUTO_SUBFRAME. See also didFailProvisionalLoad for how we
     // handle loading of error pages.
     navigation_state->set_transition_type(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   base::TimeTicks navigation_start =
       navigation_state->common_params().navigation_start;
   DCHECK(!navigation_start.is_null());
 
   for (auto& observer : render_view_->observers())
-    observer.DidStartProvisionalLoad(frame);
+    observer.DidStartProvisionalLoad(frame_);
   for (auto& observer : observers_)
     observer.DidStartProvisionalLoad();
 
   Send(new FrameHostMsg_DidStartProvisionalLoad(
       routing_id_, ds->getRequest().url(), navigation_start));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK_EQ(frame_, frame);
@@ skipping 49 matching lines @@
     pending_navigation_params_.reset(new NavigationParams(
         navigation_state->common_params(), navigation_state->start_params(),
         navigation_state->request_params()));
   }
 
   // Load an error page.
   LoadNavigationErrorPage(failed_request, error, replace, nullptr);
 }
 
 void RenderFrameImpl::didCommitProvisionalLoad(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* data_source,
+    blink::WebFrameLoadType load_type,
     const blink::WebHistoryItem& item,
     blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT2("navigation,rail", "RenderFrameImpl::didCommitProvisionalLoad",
                "id", routing_id_,
                "url", GetLoadingUrl().possibly_invalid_spec());
-  DCHECK_EQ(frame_, frame);
 
   // TODO(dcheng): Remove this UMA once we have enough measurements.
   // Record the number of subframes where window.name changes between the
   // creation of the frame and the first commit that records a history entry
   // with a persisted unique name. We'd like to make unique name immutable to
   // simplify code, but it's unclear if there are site that depend on the
   // following pattern:
   //   1. Create a new subframe.
   //   2. Assign it a window.name.
   //   3. Navigate it.
@@ skipping 17 matching lines @@
   //     Record if window.name has changed.
   if (!committed_first_load_ && !current_history_item_.isNull()) {
     if (!IsMainFrame()) {
       UMA_HISTOGRAM_BOOLEAN(
           "SessionRestore.SubFrameUniqueNameChangedBeforeFirstCommit",
           name_changed_before_first_commit_);
     }
     committed_first_load_ = true;
   }
 
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->dataSource());
+  DocumentState* document_state = DocumentState::FromDataSource(data_source);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   WebURLResponseExtraDataImpl* extra_data =
-      GetExtraDataFromResponse(frame->dataSource()->response());
+      GetExtraDataFromResponse(data_source->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()) {
     previews_state_ =
         extra_data ? extra_data->previews_state() : PREVIEWS_OFF;
     if (extra_data) {
       effective_connection_type_ =
           EffectiveConnectionTypeToWebEffectiveConnectionType(
               extra_data->effective_connection_type());
@@ skipping 51 matching lines @@
   } else {
     if (request_params.nav_entry_id != 0 &&
         !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);
+    observer.DidCommitProvisionalLoad(frame_, is_new_navigation);
   for (auto& observer : observers_) {
     observer.DidCommitProvisionalLoad(is_new_navigation,
                                       navigation_state->WasWithinSamePage());
   }
 
-  if (!frame->parent()) {  // Only for top frames.
+  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.
       if (commit_type != blink::WebHistoryInertCommit ||
           PageTransitionCoreTypeIs(
               navigation_state->GetTransitionType(),
               ui::PAGE_TRANSITION_RELOAD)) {
         render_thread_impl->GetRendererScheduler()->OnNavigationStarted();
       }
     }
   }
 
   // Remember that we've already processed this request, so we don't update
   // the session history again.  We do this regardless of whether this is
   // a session history navigation, because if we attempted a session history
   // navigation without valid HistoryItem state, WebCore will think it is a
   // new navigation.
   navigation_state->set_request_committed(true);
 
-  SendDidCommitProvisionalLoad(frame, commit_type, item);
+  SendDidCommitProvisionalLoad(data_source, load_type, item);
 
   // Check whether we have new encoding name.
-  UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
+  UpdateEncoding(frame_, frame_->view()->pageEncoding().utf8());
 }
 
 void RenderFrameImpl::didCreateNewDocument(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
 
   for (auto& observer : observers_)
     observer.DidCreateNewDocument();
   for (auto& observer : render_view_->observers())
     observer.DidCreateNewDocument(frame);
 }
@@ skipping 277 matching lines @@
           memory_metrics.non_discardable_total_allocated_mb);
       UMA_HISTOGRAM_MEMORY_MB(
           "Memory.Experimental.Renderer.TotalAllocatedPerRenderView."
           "MainFrameDidFinishLoad",
           memory_metrics.total_allocated_per_render_view_mb);
     }
   }
 }
 
 void RenderFrameImpl::didNavigateWithinPage(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* data_source,
+    blink::WebFrameLoadType load_type,
     const blink::WebHistoryItem& item,
     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());
+  DocumentState* document_state = DocumentState::FromDataSource(data_source);
   UpdateNavigationState(document_state, true /* was_within_same_page */,
                         content_initiated);
   static_cast<NavigationStateImpl*>(document_state->navigation_state())
       ->set_was_within_same_page(true);
 
-  didCommitProvisionalLoad(frame, item, commit_type);
+  didCommitProvisionalLoad(data_source, load_type, item, commit_type);
 }
 
 void RenderFrameImpl::didUpdateCurrentHistoryItem() {
   render_view_->StartNavStateSyncTimerIfNecessary(this);
 }
 
 void RenderFrameImpl::didChangeThemeColor() {
   if (frame_->parent())
     return;
 
@@ skipping 157 matching lines @@
 void RenderFrameImpl::saveImageFromDataURL(const blink::WebString& data_url) {
   // Note: We should basically send GURL but we use size-limited string instead
   // in order to send a larger data url to save a image for <canvas> or <img>.
   if (data_url.length() < kMaxLengthOfDataURLString) {
     Send(new FrameHostMsg_SaveImageFromDataURL(
          render_view_->GetRoutingID(), routing_id_, data_url.utf8()));
   }
 }
 
 void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
-                                      blink::WebURLRequest& request) {
+                                      blink::WebURLRequest& request,
+                                      blink::WebFrameLoadType load_type) {
   DCHECK_EQ(frame_, frame);
 
   // Set the first party for cookies url if it has not been set yet (new
   // requests). This value will be updated during redirects, consistent with
   // https://tools.ietf.org/html/draft-west-first-party-cookies-04#section-2.1.1
   if (request.firstPartyForCookies().isEmpty()) {
     if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel)
       request.setFirstPartyForCookies(request.url());
     else
       request.setFirstPartyForCookies(frame->document().firstPartyForCookies());
@@ skipping 66 matching lines @@
       else
         request.setHTTPHeaderField("X-Requested-With", requested_with);
     }
     stream_override = old_extra_data->TakeStreamOverrideOwnership();
   }
 
   // Add an empty HTTP origin header for non GET methods if none is currently
   // present.
   request.addHTTPOriginIfNeeded(WebSecurityOrigin::createUnique());
 
-  // Attach |should_replace_current_entry| state to requests so that, should
-  // this navigation later require a request transfer, all state is preserved
-  // when it is re-created in the new process.
-  bool should_replace_current_entry = data_source->replacesCurrentHistoryItem();
-
   int provider_id = kInvalidServiceWorkerProviderId;
   if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel ||
       request.getFrameType() == blink::WebURLRequest::FrameTypeNested) {
     // |provisionalDataSource| may be null in some content::ResourceFetcher
     // use cases, we don't hook those requests.
     if (frame->provisionalDataSource()) {
       ServiceWorkerNetworkProvider* provider =
           ServiceWorkerNetworkProvider::FromDocumentState(
               DocumentState::FromDataSource(frame->provisionalDataSource()));
       DCHECK(provider);
@@ skipping 28 matching lines @@
   extra_data->set_requested_with(requested_with);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(!parent);
   extra_data->set_frame_origin(
       url::Origin(frame->document().getSecurityOrigin()));
   extra_data->set_parent_is_main_frame(parent && !parent->parent());
   extra_data->set_parent_render_frame_id(parent_routing_id);
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
-  extra_data->set_should_replace_current_entry(should_replace_current_entry);
+  extra_data->set_should_replace_current_entry(
+      load_type == WebFrameLoadType::ReplaceCurrentItem);
   extra_data->set_service_worker_provider_id(provider_id);
   extra_data->set_stream_override(std::move(stream_override));
   bool is_prefetch =
       GetContentClient()->renderer()->IsPrefetchOnly(this, request);
   extra_data->set_is_prefetch(is_prefetch);
   extra_data->set_download_to_network_cache_only(
       is_prefetch &&
       WebURLRequestToResourceType(request) != RESOURCE_TYPE_MAIN_FRAME);
   extra_data->set_initiated_in_secure_context(
       frame->document().isSecureContext());
@@ skipping 461 matching lines @@
   return is_local_root;
 }
 
 const RenderFrameImpl* RenderFrameImpl::GetLocalRoot() const {
   return IsLocalRoot() ? this
                        : RenderFrameImpl::FromWebFrame(frame_->localRoot());
 }
 
 // Tell the embedding application that the URL of the active page has changed.
 void RenderFrameImpl::SendDidCommitProvisionalLoad(
-    blink::WebFrame* frame,
-    blink::WebHistoryCommitType commit_type,
+    blink::WebDataSource* ds,
+    blink::WebFrameLoadType load_type,
     const blink::WebHistoryItem& item) {
-  DCHECK_EQ(frame_, frame);
-  WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->getRequest();
   const WebURLResponse& response = ds->response();
 
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
   // Set the correct engagement level on the frame, and wipe the cached origin
   // so this will not be reused accidentally.
   if (url::Origin(frame_->getSecurityOrigin()) == engagement_level_.first) {
     frame_->setEngagementLevel(engagement_level_.second);
     engagement_level_.first = url::Origin();
   }
 
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.http_status_code = response.httpStatusCode();
   params.url_is_unreachable = ds->hasUnreachableURL();
   params.method = "GET";
   params.intended_as_new_entry =
       navigation_state->request_params().intended_as_new_entry;
-  params.did_create_new_entry = commit_type == blink::WebStandardCommit;
-  params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
+  params.did_create_new_entry = load_type == WebFrameLoadType::Standard;
+  params.should_replace_current_entry =
+      load_type == WebFrameLoadType::ReplaceCurrentItem;
   params.post_id = -1;
   params.nav_entry_id = navigation_state->request_params().nav_entry_id;
   // 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();
 
   // Set the origin of the frame.  This will be replicated to the corresponding
   // RenderFrameProxies in other processes.
-  params.origin = frame->document().getSecurityOrigin();
+  params.origin = frame_->document().getSecurityOrigin();
 
-  params.insecure_request_policy = frame->getInsecureRequestPolicy();
+  params.insecure_request_policy = frame_->getInsecureRequestPolicy();
 
   params.has_potentially_trustworthy_unique_origin =
-      frame->document().getSecurityOrigin().isUnique() &&
-      frame->document().getSecurityOrigin().isPotentiallyTrustworthy();
+      frame_->document().getSecurityOrigin().isUnique() &&
+      frame_->document().getSecurityOrigin().isPotentiallyTrustworthy();
 
   // Set the URL to be displayed in the browser UI to the user.
   params.url = GetLoadingUrl();
-  if (GURL(frame->document().baseURL()) != params.url)
-    params.base_url = frame->document().baseURL();
+  if (GURL(frame_->document().baseURL()) != params.url)
+    params.base_url = frame_->document().baseURL();
 
   GetRedirectChain(ds, &params.redirects);
   params.should_update_history =
       !ds->hasUnreachableURL() && response.httpStatusCode() != 404;
 
   params.searchable_form_url = internal_data->searchable_form_url();
   params.searchable_form_encoding = internal_data->searchable_form_encoding();
 
   params.gesture = render_view_->navigation_gesture_;
   render_view_->navigation_gesture_ = NavigationGestureUnknown;
@@ skipping 12 matching lines @@
   params.item_sequence_number = item.itemSequenceNumber();
   params.document_sequence_number = item.documentSequenceNumber();
 
   // If the page contained a client redirect (meta refresh, document.loc...),
   // set the referrer appropriately.
   if (ds->isClientRedirect()) {
     params.referrer =
         Referrer(params.redirects[0], ds->getRequest().getReferrerPolicy());
   } else {
     params.referrer =
-        RenderViewImpl::GetReferrerFromRequest(frame, ds->getRequest());
+        RenderViewImpl::GetReferrerFromRequest(frame_, ds->getRequest());
   }
 
-  if (!frame->parent()) {
+  if (!frame_->parent()) {
     // Top-level navigation.
 
     // Reset the zoom limits in case a plugin had changed them previously. This
     // will also call us back which will cause us to send a message to
     // update WebContentsImpl.
     render_view_->webview()->zoomLimitsChanged(
         ZoomFactorToZoomLevel(kMinimumZoomFactor),
         ZoomFactorToZoomLevel(kMaximumZoomFactor));
 
     // Set zoom level, but don't do it for full-page plugin since they don't use
@@ skipping 49 matching lines @@
 
     // Track the URL of the original request.  We use the first entry of the
     // redirect chain if it exists because the chain may have started in another
     // process.
     params.original_request_url = GetOriginalRequestURL(ds);
 
     params.history_list_was_cleared =
         navigation_state->request_params().should_clear_history_list;
 
     params.report_type = static_cast<FrameMsg_UILoadMetricsReportType::Value>(
-        frame->dataSource()->getRequest().inputPerfMetricReportPolicy());
-    params.ui_timestamp = base::TimeTicks() +
-                          base::TimeDelta::FromSecondsD(
-                              frame->dataSource()->getRequest().uiStartTime());
+        ds->getRequest().inputPerfMetricReportPolicy());
+    params.ui_timestamp =
+        base::TimeTicks() +
+        base::TimeDelta::FromSecondsD(ds->getRequest().uiStartTime());
   } else {
     // Subframe navigation: the type depends on whether this navigation
     // generated a new session history entry. When they do generate a session
     // history entry, it means the user initiated the navigation and we should
     // mark it as such.
-    if (commit_type == blink::WebStandardCommit)
+    if (load_type == WebFrameLoadType::Standard)
       params.transition = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
     else
       params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
 
     DCHECK(!navigation_state->request_params().should_clear_history_list);
     params.history_list_was_cleared = false;
     params.report_type = FrameMsg_UILoadMetricsReportType::NO_REPORT;
     // Subframes should match the zoom level of the main frame.
     render_view_->SetZoomLevel(render_view_->page_zoom_level());
   }
@@ skipping 236 matching lines @@
   bool is_content_initiated =
       info.extraData
           ? static_cast<DocumentState*>(info.extraData)
                 ->navigation_state()
                 ->IsContentInitiated()
           : !IsBrowserInitiated(pending_navigation_params_.get());
   bool is_redirect =
       info.extraData ||
       (pending_navigation_params_ &&
        !pending_navigation_params_->request_params.redirects.empty());
+  bool is_reload = info.loadType == WebFrameLoadType::Reload ||
+                   info.loadType == WebFrameLoadType::ReloadMainResource ||
+                   info.loadType == WebFrameLoadType::ReloadBypassingCache;
 
 #ifdef OS_ANDROID
   bool render_view_was_created_by_renderer =
       render_view_->was_created_by_renderer_;
   // The handlenavigation API is deprecated and will be removed once
   // crbug.com/325351 is resolved.
   if (GetContentClient()->renderer()->HandleNavigation(
           this, is_content_initiated, render_view_was_created_by_renderer,
-          frame_, info.urlRequest, info.navigationType, info.defaultPolicy,
+          frame_, info.urlRequest,
+          info.loadType == WebFrameLoadType::BackForward, info.defaultPolicy,
           is_redirect)) {
     return blink::WebNavigationPolicyIgnore;
   }
 #endif
 
   Referrer referrer(
       RenderViewImpl::GetReferrerFromRequest(frame_, info.urlRequest));
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = info.urlRequest.url();
 
   // If the browser is interested, then give it a chance to look at the request.
   if (is_content_initiated && IsTopLevelNavigation(frame_) &&
       render_view_->renderer_preferences_
           .browser_handles_all_top_level_requests) {
     OpenURL(url, IsHttpPost(info.urlRequest),
             GetRequestBodyForWebURLRequest(info.urlRequest),
             GetWebURLRequestHeaders(info.urlRequest), referrer,
-            info.defaultPolicy, info.replacesCurrentHistoryItem, false);
+            info.defaultPolicy, info.loadType);
     return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
   }
 
   // Back/forward navigations in newly created subframes should be sent to the
   // browser if there is a matching FrameNavigationEntry, and if it isn't just
   // staying at about:blank.  If this frame isn't in the map of unique names
   // that have history items, or if it's staying at the initial about:blank URL,
   // fall back to loading the default url.  (We remove each name as we encounter
   // it, because it will only be used once as the frame is created.)
-  if (info.isHistoryNavigationInNewChildFrame && is_content_initiated &&
-      frame_->parent()) {
+  if (info.loadType == WebFrameLoadType::InitialHistoryLoad &&
+      is_content_initiated && frame_->parent()) {
     // Check whether the browser has a history item for this frame that isn't
     // just staying at the initial about:blank document.
     bool should_ask_browser = false;
     RenderFrameImpl* parent = RenderFrameImpl::FromWebFrame(frame_->parent());
     const auto& iter = parent->history_subframe_unique_names_.find(
         frame_->uniqueName().utf8());
     if (iter != parent->history_subframe_unique_names_.end()) {
       bool history_item_is_about_blank = iter->second;
       should_ask_browser =
           !history_item_is_about_blank || url != url::kAboutBlankURL;
       parent->history_subframe_unique_names_.erase(frame_->uniqueName().utf8());
     }
 
     if (should_ask_browser) {
       // Don't do this if |info| also says it is a client redirect, in which
       // case JavaScript on the page is trying to interrupt the history
       // navigation.
       if (!info.isClientRedirect) {
         OpenURL(url, IsHttpPost(info.urlRequest),
                 GetRequestBodyForWebURLRequest(info.urlRequest),
                 GetWebURLRequestHeaders(info.urlRequest), referrer,
-                info.defaultPolicy, info.replacesCurrentHistoryItem, true);
+                info.defaultPolicy, info.loadType);
         // Suppress the load in Blink but mark the frame as loading.
         return blink::WebNavigationPolicyHandledByClient;
       } else {
         // Client redirects during an initial history load should attempt to
         // cancel the history navigation.  They will create a provisional
         // document loader, causing the history load to be ignored in
         // NavigateInternal, and this IPC will try to cancel any cross-process
         // history load.
         Send(new FrameHostMsg_CancelInitialHistoryLoad(routing_id_));
       }
@@ skipping 21 matching lines @@
     // must be handled by the browser process (except for reloads - those are
     // safe to leave within the renderer).
     // Lastly, access to file:// URLs from non-file:// URL pages must be
     // handled by the browser so that ordinary renderer processes don't get
     // blessed with file permissions.
     int cumulative_bindings = RenderProcess::current()->GetEnabledBindings();
     bool is_initial_navigation = render_view_->history_list_length_ == 0;
     bool should_fork = HasWebUIScheme(url) || HasWebUIScheme(old_url) ||
                        (cumulative_bindings & BINDINGS_POLICY_WEB_UI) ||
                        url.SchemeIs(kViewSourceScheme) ||
-                       (frame_->isViewSourceModeEnabled() &&
-                        info.navigationType != blink::WebNavigationTypeReload);
+                       (frame_->isViewSourceModeEnabled() && is_reload);
 
     if (!should_fork && url.SchemeIs(url::kFileScheme)) {
       // Fork non-file to file opens.  Note that this may fork unnecessarily if
       // another tab (hosting a file or not) targeted this one before its
       // initial navigation, but that shouldn't cause a problem.
       should_fork = !old_url.SchemeIs(url::kFileScheme);
     }
 
     if (!should_fork) {
       // Give the embedder a chance.
       should_fork = GetContentClient()->renderer()->ShouldFork(
           frame_, url, info.urlRequest.httpMethod().utf8(),
           is_initial_navigation, is_redirect, &send_referrer);
     }
 
     if (should_fork) {
       OpenURL(url, IsHttpPost(info.urlRequest),
               GetRequestBodyForWebURLRequest(info.urlRequest),
               GetWebURLRequestHeaders(info.urlRequest),
               send_referrer ? referrer : Referrer(), info.defaultPolicy,
-              info.replacesCurrentHistoryItem, false);
+              info.loadType);
       return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
   // renderer for a cross-site navigation), rather than WebKit navigations.
   //
@@ skipping 13 matching lines @@
       render_view_->historyForwardListCount() < 1 &&
       // The parent page must have set the child's window.opener to null before
       // redirecting to the desired URL.
       frame_->opener() == NULL &&
       // Must be a top-level frame.
       frame_->parent() == NULL &&
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab &&
-      // Must be a JavaScript navigation, which appears as "other".
-      info.navigationType == blink::WebNavigationTypeOther;
+      // Must be a JavaScript navigation.
+      info.isClientRedirect;
 
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(url, IsHttpPost(info.urlRequest),
             GetRequestBodyForWebURLRequest(info.urlRequest),
             GetWebURLRequestHeaders(info.urlRequest), Referrer(),
-            info.defaultPolicy, info.replacesCurrentHistoryItem, false);
+            info.defaultPolicy, info.loadType);
     return blink::WebNavigationPolicyIgnore;
   }
 
   bool should_dispatch_before_unload =
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab &&
       // There is no need to execute the BeforeUnload event during a redirect,
       // since it was already executed at the start of the navigation.
       !is_redirect &&
       // PlzNavigate: this should not be executed when commiting the navigation.
       (!IsBrowserSideNavigationEnabled() ||
        info.urlRequest.checkForBrowserSideNavigation()) &&
       // No need to dispatch beforeunload if the frame has not committed a
       // navigation and contains an empty initial document.
       (has_accessed_initial_document_ || !current_history_item_.isNull());
 
   if (should_dispatch_before_unload) {
     // Execute the BeforeUnload event. If asked not to proceed or the frame is
     // destroyed, ignore the navigation.
     // Keep a WeakPtr to this RenderFrameHost to detect if executing the
     // BeforeUnload event destriyed this frame.
     base::WeakPtr<RenderFrameImpl> weak_self = weak_factory_.GetWeakPtr();
 
-    if (!frame_->dispatchBeforeUnloadEvent(info.navigationType ==
-                                           blink::WebNavigationTypeReload) ||
-        !weak_self) {
+    if (!frame_->dispatchBeforeUnloadEvent(is_reload) || !weak_self)
       return blink::WebNavigationPolicyIgnore;
-    }
 
     // |navigation_start| must be recorded immediately after dispatching the
     // beforeunload event.
     if (pending_navigation_params_) {
       pending_navigation_params_->common_params.navigation_start =
           base::TimeTicks::Now();
     }
   }
 
   // PlzNavigate: if the navigation is not synchronous, send it to the browser.
@@ skipping 313 matching lines @@
 #endif
 #endif
 
 void RenderFrameImpl::OpenURL(
     const GURL& url,
     bool uses_post,
     const scoped_refptr<ResourceRequestBodyImpl>& resource_request_body,
     const std::string& extra_headers,
     const Referrer& referrer,
     WebNavigationPolicy policy,
-    bool should_replace_current_entry,
-    bool is_history_navigation_in_new_child) {
+    WebFrameLoadType load_type) {
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
   params.uses_post = uses_post;
   params.resource_request_body = resource_request_body;
   params.extra_headers = extra_headers;
   params.referrer = referrer;
   params.disposition = RenderViewImpl::NavigationPolicyToDisposition(policy);
 
-  if (IsBrowserInitiated(pending_navigation_params_.get())) {
-    // This is necessary to preserve the should_replace_current_entry value on
-    // cross-process redirects, in the event it was set by a previous process.
-    WebDataSource* ds = frame_->provisionalDataSource();
-    DCHECK(ds);
-    params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
-  } else {
-    params.should_replace_current_entry =
-        should_replace_current_entry && render_view_->history_list_length_;
-  }
+  params.should_replace_current_entry =
+      load_type == WebFrameLoadType::ReplaceCurrentItem &&
+      (IsBrowserInitiated(pending_navigation_params_.get()) ||
+       render_view_->history_list_length_);
   params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
   if (GetContentClient()->renderer()->AllowPopup())
     params.user_gesture = true;
 
   if (policy == blink::WebNavigationPolicyNewBackgroundTab ||
       policy == blink::WebNavigationPolicyNewForegroundTab ||
       policy == blink::WebNavigationPolicyNewWindow ||
       policy == blink::WebNavigationPolicyNewPopup) {
     WebUserGestureIndicator::consumeUserGesture();
   }
 
-  if (is_history_navigation_in_new_child)
+  if (load_type == WebFrameLoadType::InitialHistoryLoad)
     params.is_history_navigation_in_new_child = true;
 
   Send(new FrameHostMsg_OpenURL(routing_id_, params));
 }
 
 void RenderFrameImpl::NavigateInternal(
     const CommonNavigationParams& common_params,
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params,
     std::unique_ptr<StreamOverrideParameters> stream_params) {
@@ skipping 375 matching lines @@
   // Note: At this stage, the goal is to apply all the modifications the
   // renderer wants to make to the request, and then send it to the browser, so
   // that the actual network request can be started. Ideally, all such
   // modifications should take place in willSendRequest, and in the
   // implementation of willSendRequest for the various InspectorAgents
   // (devtools).
   //
   // TODO(clamy): Apply devtools override.
   // TODO(clamy): Make sure that navigation requests are not modified somewhere
   // else in blink.
-  willSendRequest(frame_, info.urlRequest);
+  willSendRequest(frame_, info.urlRequest, info.loadType);
 
   // Update the transition type of the request for client side redirects.
   if (!info.urlRequest.getExtraData())
     info.urlRequest.setExtraData(new RequestExtraData());
   if (info.isClientRedirect) {
     RequestExtraData* extra_data =
         static_cast<RequestExtraData*>(info.urlRequest.getExtraData());
     extra_data->set_transition_type(ui::PageTransitionFromInt(
         extra_data->transition_type() | ui::PAGE_TRANSITION_CLIENT_REDIRECT));
   }
@@ skipping 608 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