Set user_gesture bit at NavigationHandle creation time.

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 620 matching lines @@
       base::TimeDelta::FromSecondsD(info.urlRequest.uiStartTime());
   FrameMsg_UILoadMetricsReportType::Value report_type =
       static_cast<FrameMsg_UILoadMetricsReportType::Value>(
           info.urlRequest.inputPerfMetricReportPolicy());
 
   FrameMsg_Navigate_Type::Value navigation_type =
       info.navigationType == blink::WebNavigationTypeReload
       ? FrameMsg_Navigate_Type::RELOAD
       : FrameMsg_Navigate_Type::NORMAL;
 
+  NavigationGesture gesture = info.urlRequest.hasUserGesture()
+                                  ? NavigationGestureUser
+                                  : NavigationGestureAuto;
   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,
-      report_type, GURL(), GURL(),
+      navigation_type, gesture, true, info.replacesCurrentHistoryItem,
+      ui_timestamp, report_type, GURL(), GURL(),
       static_cast<LoFiState>(info.urlRequest.getLoFiState()),
       base::TimeTicks::Now(), info.urlRequest.httpMethod().latin1(),
       GetRequestBodyForWebURLRequest(info.urlRequest));
 }
 
 media::Context3D GetSharedMainThreadContext3D(
     scoped_refptr<ContextProviderCommandBuffer> provider) {
   if (!provider)
     return media::Context3D();
   return media::Context3D(provider->ContextGL(), provider->GrContext());
@@ skipping 2687 matching lines @@
   if (!ds)
     return;
 
   TRACE_EVENT2("navigation,benchmark,rail",
                "RenderFrameImpl::didStartProvisionalLoad", "id", routing_id_,
                "url", ds->request().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();
+  NavigationGesture gesture = WebUserGestureIndicator::isProcessingUserGesture()
+                                  ? NavigationGestureUser
+                                  : NavigationGestureAuto;
   if (is_top_most) {
-    render_view_->set_navigation_gesture(
-        WebUserGestureIndicator::isProcessingUserGesture() ?
-            NavigationGestureUser : NavigationGestureAuto);
+    render_view_->set_navigation_gesture(gesture);
   } else if (ds->replacesCurrentHistoryItem()) {
     // 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);
   for (auto& observer : observers_)
     observer.DidStartProvisionalLoad();
 
   Send(new FrameHostMsg_DidStartProvisionalLoad(
-      routing_id_, ds->request().url(), navigation_start));
+      routing_id_, ds->request().url(), navigation_start, gesture));
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
   DCHECK_EQ(frame_, frame);
 
   // We don't use HistoryController in OOPIF enabled modes.
   if (SiteIsolationPolicy::UseSubframeNavigationEntries())
     return;
 
@@ skipping 1357 matching lines @@
   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;
+  params.gesture = render_view_->navigation_gesture();
+  render_view_->set_navigation_gesture(NavigationGestureUnknown);
 
   // Make navigation state a part of the DidCommitProvisionalLoad message so
   // that committed entry has it at all times.
   int64_t post_id = -1;
   if (!SiteIsolationPolicy::UseSubframeNavigationEntries()) {
     HistoryEntry* entry = render_view_->history_controller()->GetCurrentEntry();
     if (entry) {
       params.page_state = HistoryEntryToPageState(entry);
       post_id = ExtractPostId(entry->root());
     } else {
@@ skipping 220 matching lines @@
   std::unique_ptr<StreamOverrideParameters> stream_override(
       new StreamOverrideParameters());
   stream_override->stream_url = stream_url;
   stream_override->response = response;
   stream_override->redirects = request_params.redirects;
   stream_override->redirect_responses = request_params.redirect_response;
 
   // If the request was initiated in the context of a user gesture then make
   // sure that the navigation also executes in the context of a user gesture.
   std::unique_ptr<blink::WebScopedUserGesture> gesture(
-      request_params.has_user_gesture ? new blink::WebScopedUserGesture(frame_)
-                                      : nullptr);
+      (common_params.gesture == NavigationGestureUser)
+          ? new blink::WebScopedUserGesture(frame_)
+          : nullptr);
 
   NavigateInternal(common_params, StartNavigationParams(), request_params,
                    std::move(stream_override));
   browser_side_navigation_pending_ = false;
 }
 
 // PlzNavigate
 void RenderFrameImpl::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
@@ skipping 704 matching lines @@
                            : blink::WebURLRequest::FrameTypeNested);
 
   if (IsBrowserSideNavigationEnabled() && common_params.post_data)
     request.setHTTPBody(GetWebHTTPBodyForRequestBody(common_params.post_data));
 
   // Used to determine whether this frame is actually loading a request as part
   // of a history navigation.
   bool has_history_navigation_in_frame = false;
 
 #if defined(OS_ANDROID)
-  request.setHasUserGesture(request_params.has_user_gesture);
+  request.setHasUserGesture(common_params.gesture == NavigationGestureUser);
 #endif
 
   if (browser_side_navigation) {
     // PlzNavigate: Make sure that Blink's loader will not try to use browser
     // side navigation for this request (since it already went to the browser).
     request.setCheckForBrowserSideNavigation(false);
 
     request.setNavigationStartTime(
         ConvertToBlinkTime(common_params.navigation_start));
   }
@@ skipping 347 matching lines @@
   DCHECK(frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(info.urlRequest) ==
              REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL);
   DCHECK(!frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(info.urlRequest) ==
              REQUEST_CONTEXT_FRAME_TYPE_NESTED);
 
   BeginNavigationParams begin_navigation_params(
       GetWebURLRequestHeaders(info.urlRequest),
       GetLoadFlagsForWebURLRequest(info.urlRequest),
-      info.urlRequest.hasUserGesture(),
       info.urlRequest.skipServiceWorker() !=
           blink::WebURLRequest::SkipServiceWorker::None,
       GetRequestContextTypeForWebURLRequest(info.urlRequest));
 
   if (!info.form.isNull()) {
     WebSearchableFormData web_searchable_form_data(info.form);
     begin_navigation_params.searchable_form_url =
         web_searchable_form_data.url();
     begin_navigation_params.searchable_form_encoding =
         web_searchable_form_data.encoding().utf8();
@@ skipping 537 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