Set user_gesture bit at NavigationHandle creation time.

content/browser/frame_host/navigator_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/browser/frame_host/navigator_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 125 matching lines @@
   return delegate_;
 }
 
 NavigationController* NavigatorImpl::GetController() {
   return controller_;
 }
 
 void NavigatorImpl::DidStartProvisionalLoad(
     RenderFrameHostImpl* render_frame_host,
     const GURL& url,
-    const base::TimeTicks& navigation_start) {
+    const base::TimeTicks& navigation_start,
+    bool has_user_gesture) {
   bool is_main_frame = render_frame_host->frame_tree_node()->IsMainFrame();
   bool is_error_page = (url.spec() == kUnreachableWebDataURL);
   bool is_iframe_srcdoc = (url.spec() == kAboutSrcDocURL);
   GURL validated_url(url);
   RenderProcessHost* render_process_host = render_frame_host->GetProcess();
   render_process_host->FilterURL(false, &validated_url);
 
   // Do not allow browser plugin guests to navigate to non-web URLs, since they
   // cannot swap processes or grant bindings.
   ChildProcessSecurityPolicyImpl* policy =
@@ skipping 45 matching lines @@
     is_renderer_initiated = pending_entry->is_renderer_initiated();
     pending_nav_entry_id = pending_entry->GetUniqueID();
     started_from_context_menu = pending_entry->has_started_from_context_menu();
   }
 
   render_frame_host->SetNavigationHandle(NavigationHandleImpl::Create(
       validated_url, render_frame_host->frame_tree_node(),
       is_renderer_initiated,
       false,             // is_same_page
       is_iframe_srcdoc,  // is_srcdoc
-      navigation_start, pending_nav_entry_id, started_from_context_menu));
+      navigation_start, pending_nav_entry_id, has_user_gesture,
+      started_from_context_menu));
 }
 
 void NavigatorImpl::DidFailProvisionalLoadWithError(
     RenderFrameHostImpl* render_frame_host,
     const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params) {
   VLOG(1) << "Failed Provisional Load: " << params.url.possibly_invalid_spec()
           << ", error_code: " << params.error_code
           << ", error_description: " << params.error_description
           << ", showing_repost_interstitial: " <<
             params.showing_repost_interstitial
@@ skipping 771 matching lines @@
         common_params.url,
         frame_tree_node->current_frame_host()->GetSiteInstance(), nullptr);
     navigation_data_.reset();
   }
 
   // For main frames, NavigationHandle will be created after the call to
   // |DidStartMainFrameNavigation|, so it receives the most up to date pending
   // entry from the NavigationController.
   NavigationEntry* pending_entry = controller_->GetPendingEntry();
   navigation_request->CreateNavigationHandle(
-      pending_entry ? pending_entry->GetUniqueID() : 0);
+      pending_entry ? pending_entry->GetUniqueID() : 0,
+      begin_params.has_user_gesture);
   navigation_request->BeginNavigation();
 }
 
 // PlzNavigate
 void NavigatorImpl::FailedNavigation(FrameTreeNode* frame_tree_node,
                                      bool has_stale_copy_in_cache,
                                      int error_code) {
   CHECK(IsBrowserSideNavigationEnabled());
 
   NavigationRequest* navigation_request = frame_tree_node->navigation_request();
@@ skipping 136 matching lines @@
             *navigation_request);
     render_frame_host->CommitNavigation(nullptr,  // response
                                         nullptr,  // body
                                         navigation_request->common_params(),
                                         navigation_request->request_params(),
                                         navigation_request->is_view_source());
     return;
   }
 
   frame_tree_node->CreatedNavigationRequest(std::move(scoped_request));
-  navigation_request->CreateNavigationHandle(entry.GetUniqueID());
+
+  // Browser-initiated navigations are not currently considered to have a user
+  // gesture, though this is intended to change as part of PlzNavigate (see the
+  // TODO(clamy) for HasUserGesture in navigation_handle.h).
+  bool has_user_gesture = false;
+  navigation_request->CreateNavigationHandle(entry.GetUniqueID(),
+                                             has_user_gesture);

[clamy, 2016/11/17 14:30:04]

We have the info about user gesture in the BeginNavigationParams inside
NavigationRequest. I'd rather we use it directly instead of passing it as a
param here.

[Bryan McQuade, 2016/11/19 20:21:38]

Ah, I missed that. Fixed, thanks!

 
   // Have the current renderer execute its beforeunload event if needed. If it
   // is not needed then NavigationRequest::BeginNavigation should be directly
   // called instead.
   if (should_dispatch_beforeunload && !IsRendererDebugURL(dest_url)) {
     navigation_request->SetWaitingForRendererResponse();
     frame_tree_node->current_frame_host()->DispatchBeforeUnload(
         true, reload_type != ReloadType::NONE);
   } else {
     navigation_request->BeginNavigation();
@@ skipping 92 matching lines @@
     if (navigation_handle)
       navigation_handle->update_entry_id_for_transfer(entry->GetUniqueID());
 
     controller_->SetPendingEntry(std::move(entry));
     if (delegate_)
       delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content