Persist prompt/block download limiter state on renderer-initiated loads.

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/metrics/histogram.h"
 #include "base/time/time.h"
@@ skipping 157 matching lines @@
       return;
     }
 
     // This ensures that notifications about the end of the previous
     // navigation are sent before notifications about the start of the
     // new navigation.
     render_frame_host->SetNavigationHandle(
         std::unique_ptr<NavigationHandleImpl>());
   }
 
-  NavigationEntry* pending_entry = controller_->GetPendingEntry();
+  bool is_renderer_initiated = false;

[Charlie Reis, 2016/05/11 21:50:03]

Seems like we should default to true, with a comment about why.  Reasoning:

It's safer to assume a navigation is renderer-initiated unless we know
otherwise, since browser-initiated navigations are generally more powerful
(e.g., can go to chrome:// URLs).  Browser-initiated navigations should always
have a pending NavigationEntry, so we should be able to detect if that's the
case here.

(Can you add a test that would have failed with the way this is currently
written?  I bet it would classify a subframe navigation as browser-initiated.)

[dominickn, 2016/05/12 04:22:58]

Makes sense, done. The test I added with subframe navigations does indeed fail
with this set to false by default. :)

+  int pending_nav_entry_id = 0;
+  NavigationEntryImpl* pending_entry = controller_->GetPendingEntry();
+  if (pending_entry) {
+    is_renderer_initiated = pending_entry->is_renderer_initiated();
+    pending_nav_entry_id = pending_entry->GetUniqueID();
+  }
   render_frame_host->SetNavigationHandle(NavigationHandleImpl::Create(
       validated_url, render_frame_host->frame_tree_node(),
+      is_renderer_initiated,
       false,             // is_synchronous
       is_iframe_srcdoc,  // is_srcdoc
-      navigation_start, pending_entry ? pending_entry->GetUniqueID() : 0));
+      navigation_start, pending_nav_entry_id));
 }
 
 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 694 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);
+      true, pending_entry ? pending_entry->GetUniqueID() : 0);
   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 79 matching lines @@
           navigation_start, controller_);
   NavigationRequest* navigation_request = scoped_request.get();
 
   // For Javascript navigations, do not assign the NavigationRequest to the
   // FrameTreeNode, as navigating to a Javascript URL should not interrupt a
   // previous navigation. BeginNavigation will have it commit, and the
   // scoped_request will be destroyed at the end of this function.
   if (!dest_url.SchemeIs(url::kJavaScriptScheme))
     frame_tree_node->CreatedNavigationRequest(std::move(scoped_request));
 
-  navigation_request->CreateNavigationHandle(entry.GetUniqueID());
+  navigation_request->CreateNavigationHandle(entry.is_renderer_initiated(),
+                                             entry.GetUniqueID());
 
   // Have the current renderer execute its beforeunload event if needed. If it
   // is not needed (when beforeunload dispatch is not needed or this navigation
   // is synchronous and same-site) then NavigationRequest::BeginNavigation
   // should be directly called instead.
   if (should_dispatch_beforeunload &&
       ShouldMakeNetworkRequestForURL(
           navigation_request->common_params().url)) {
     navigation_request->SetWaitingForRendererResponse();
     frame_tree_node->current_frame_host()->DispatchBeforeUnload(true);
@@ skipping 87 matching lines @@
     if (pending_entry) {
       entry->set_transferred_global_request_id(
           pending_entry->transferred_global_request_id());
       entry->set_should_replace_entry(pending_entry->should_replace_entry());
       entry->SetRedirectChain(pending_entry->GetRedirectChain());
     }
 
     // If there's a current NavigationHandle, update its pending NavEntry ID.
     // This is necessary for transfer navigations.  The handle may be null in
     // PlzNavigate.
-    if (navigation_handle)
+    if (navigation_handle) {
+      navigation_handle->set_is_renderer_initiated(true);
       navigation_handle->update_entry_id_for_transfer(entry->GetUniqueID());
+    }
 
     controller_->SetPendingEntry(std::move(entry));
     if (delegate_)
       delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
   }
 }
 
 void NavigatorImpl::DiscardPendingEntryOnFailureIfNeeded(
     NavigationHandleImpl* handle) {
   // Racy conditions can cause a fail message to arrive after its corresponding
@@ skipping 29 matching lines @@
   if (pending_entry != controller_->GetVisibleEntry() ||
       !should_preserve_entry) {
     controller_->DiscardPendingEntry(true);
 
     // Also force the UI to refresh.
     controller_->delegate()->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content