Introduce the ThrottleManager

components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc

Index: components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc
diff --git a/components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc b/components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e20161e8d426769886844e0fb8e61e77aa16c29e
--- /dev/null
+++ b/components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.cc
@@ -0,0 +1,163 @@
+// Copyright 2017 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 "components/subresource_filter/content/browser/content_subresource_filter_throttle_manager.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "components/subresource_filter/content/browser/activation_state_computing_navigation_throttle.h"
+#include "components/subresource_filter/content/browser/async_document_subresource_filter.h"
+#include "components/subresource_filter/content/browser/subframe_navigation_filtering_throttle.h"
+#include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+
+namespace subresource_filter {
+
+FrameActivationInfo::FrameActivationInfo() {}
+FrameActivationInfo::~FrameActivationInfo() {}
+
+bool ContentSubresourceFilterThrottleManager::Delegate::ShouldVetoActivation(
+    content::NavigationHandle* navigation_handle) {
+  return false;
+}
+
+ContentSubresourceFilterThrottleManager::
+    ContentSubresourceFilterThrottleManager(
+        Delegate* delegate,
+        VerifiedRulesetDealer::Handle* dealer_handle,
+        content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents),
+      dealer_handle_(dealer_handle),
+      delegate_(delegate) {}
+
+ContentSubresourceFilterThrottleManager::
+    ~ContentSubresourceFilterThrottleManager() {}
+
+void ContentSubresourceFilterThrottleManager::OnPageStateActivationComputed(

[engedy, 2017/02/17 20:44:44]

nit: For consistency, what do you think about calling this
NotifyPageLevelActivationComputed (or NotifyPageActivationComputed)?

[Charlie Harrison, 2017/02/17 22:12:31]

Sure, renamed to NotifyPageActivationComputed.

+    content::NavigationHandle* activated_navigation,
+    const ActivationState& state) {

[engedy, 2017/02/17 20:44:44]

nit: %s/ state/ activation_state/g

[Charlie Harrison, 2017/02/17 22:12:31]

Done, here and throughout the file.

+  DCHECK(activated_navigation->IsInMainFrame());
+  DCHECK(!activated_navigation->HasCommitted());
+  auto it = ongoing_activation_throttles_.find(activated_navigation);
+  if (it != ongoing_activation_throttles_.end()) {
+    it->second->NotifyPageActivationWithRuleset(
+        EnsureRulesetHandle(), state,
+        base::Bind(&ContentSubresourceFilterThrottleManager::Delegate::
+                       OnFirstSubresourceLoadDisallowed,

[engedy, 2017/02/17 20:44:44]

Note that, later, we will need to clean up this signal so that the Delegate gets
at most one callback per main frame navigation, even if there are resources
disallowed in multiple frames. Also, we need to integrate the signals coming
from the SubresourceFilterAgents on the renderer side the same way.

[Charlie Harrison, 2017/02/17 22:12:31]

I think the coalescing should be done in this class, I can try to tackle it in
this CL. I was imagining the renderer IPCing this information to this class, and
I will add a TODO to that effect.

This shouldn't be too hard, because there is at most one committed main frame
navigation per WebContents at a time. I will encode it as a bool.

[engedy, 2017/02/20 15:58:13]

Sounds good, let's do that in a follow-up CL.

ChromeSubresourceFilterClient::ToggleNotificationVisibility already does some
deduplication, it would be nice to clean that up a bit too.

+                   delegate_->AsWeakPtr()));
+  }
+}
+
+void ContentSubresourceFilterThrottleManager::RenderFrameDeleted(
+    content::RenderFrameHost* frame_host) {
+  activated_frame_hosts_.erase(frame_host);
+  if (activated_frame_hosts_.size() == 0)
+    ruleset_handle_.reset();
+}
+
+// Pull the AsyncDocumentSubresourceFilter and its associated ActivationState
+// out of the activation state computing throttle. Store it for later filtering
+// of subframe navigations.
+void ContentSubresourceFilterThrottleManager::ReadyToCommitNavigation(
+    content::NavigationHandle* navigation_handle) {
+  content::RenderFrameHost* frame_host =
+      navigation_handle->GetRenderFrameHost();
+  // Make sure that if the committed navigation is in a RenderFrameHost that is
+  // already activated, the activation state is reset. This is important in the
+  // case where this navigation does *not* trigger activation.
+  activated_frame_hosts_.erase(frame_host);

[engedy, 2017/02/17 20:44:44]

nit: It's a bit hard to argue about |ruleset_handle_| lifetime here.

In the admittedly unlikely case where there are no subframes, suppose the
current main frame has activation, and we navigation away to a same-origin page
that does not have activation. Do we ever free up the |ruleset_handle| in this
case?

[Charlie Harrison, 2017/02/17 22:12:31]

You're right, this is hard to reason about. Essentially the handle is ref-bumped
per every activated RenderFrameHost, and derefed when that RenderFrameHost is no
longer active. The deref is "lazy" in the sense that we only check this when a
RenderFrame is deleted, which does not happen for same-site navigations.

Probably we can improve things here. The "cleanest" solution would be to get rid
of the lazy wart, and make sure the handle is destroyed whenever we have no
activated frames. I've done that here, let me know what you think.

+
+  auto throttle = ongoing_activation_throttles_.find(navigation_handle);
+  if (throttle == ongoing_activation_throttles_.end())
+    return;
+
+  const ActivationState& state = throttle->second->GetActivationState();
+  if (state.activation_level == ActivationLevel::DISABLED ||
+      delegate_->ShouldVetoActivation(navigation_handle))
+    return;
+
+  auto info = base::MakeUnique<FrameActivationInfo>();
+  info->subresource_filter = throttle->second->ReleaseFilter();
+  info->activation_state = state;
+  DCHECK(info->subresource_filter);
+  activated_frame_hosts_[navigation_handle->GetRenderFrameHost()] =

[engedy, 2017/02/17 20:44:44]

nit: activated_frame_hosts_[frame_host]

[Charlie Harrison, 2017/02/17 22:12:31]

Done.

+      std::move(info);
+  // TODO(csharrison): Send an IPC to the renderer.
+}
+
+void ContentSubresourceFilterThrottleManager::DidFinishNavigation(
+    content::NavigationHandle* navigation_handle) {
+  ongoing_activation_throttles_.erase(navigation_handle);
+}
+
+void ContentSubresourceFilterThrottleManager::MaybeInsertNavigationThrottles(

[engedy, 2017/02/17 20:44:44]

nit: MaybeAppendNavigationThrottles

[Charlie Harrison, 2017/02/17 22:12:31]

Done.

+    content::NavigationHandle* navigation_handle,
+    std::vector<std::unique_ptr<content::NavigationThrottle>>* throttles) {
+  if (std::unique_ptr<content::NavigationThrottle> filtering_throttle =
+          MaybeCreateSubframeNavigationFilteringThrottle(navigation_handle)) {
+    throttles->push_back(std::move(filtering_throttle));
+  }
+  if (std::unique_ptr<content::NavigationThrottle> activation_throttle =
+          MaybeCreateActivationStateComputingThrottle(navigation_handle)) {
+    throttles->push_back(std::move(activation_throttle));
+  }
+}
+
+std::unique_ptr<content::NavigationThrottle>
+ContentSubresourceFilterThrottleManager::
+    MaybeCreateSubframeNavigationFilteringThrottle(
+        content::NavigationHandle* navigation_handle) {
+  if (navigation_handle->IsInMainFrame() || navigation_handle->IsSamePage())

[engedy, 2017/02/17 20:44:44]

Could you please verify what happens here for navigations synchronously
committed on the renderer side (like about:blank) and for error page loads? 
Throttles are never invoked for these, it seems wasteful to create them in the
first place (and muddies up metrics). 

[Charlie Harrison, 2017/02/17 22:12:31]

Yes I think same-page navigations and all synchronous navigations (about:blank,
etc) do not invoke throttles, I just tested this with PlzNavigate turned on and
off. Turned these checks into DCHECKs.

[engedy, 2017/02/20 15:58:13]

Awesome, thanks for checking!

[engedy, 2017/03/10 17:36:20]

To quote a popular meme:

-- Tell me you turned these conditionals into DCHECKs.
-- Okay. I haven't, though.

[Charlie Harrison, 2017/03/14 23:18:31]

LOL. Done.

+    return nullptr;
+  FrameActivationInfo* info =
+      GetFrameActivationInfoForChildNavigation(navigation_handle);
+  return info ? base::MakeUnique<SubframeNavigationFilteringThrottle>(
+                    navigation_handle, info->subresource_filter.get())
+              : nullptr;
+}
+
+std::unique_ptr<content::NavigationThrottle>
+ContentSubresourceFilterThrottleManager::
+    MaybeCreateActivationStateComputingThrottle(
+        content::NavigationHandle* navigation_handle) {
+  if (navigation_handle->IsSamePage())
+    return nullptr;
+
+  // Main frames: create unconditionally.
+  if (navigation_handle->IsInMainFrame())
+    return ActivationStateComputingNavigationThrottle::CreateForMainFrame(
+        navigation_handle);
+
+  // Subframes: create only for frames with activated parents.
+  FrameActivationInfo* info =
+      GetFrameActivationInfoForChildNavigation(navigation_handle);
+  if (!info)
+    return nullptr;
+  DCHECK(ruleset_handle_);
+  return ActivationStateComputingNavigationThrottle::CreateForSubframe(
+      navigation_handle, ruleset_handle_.get(), info->activation_state,
+      base::Bind(&Delegate::OnFirstSubresourceLoadDisallowed,
+                 delegate_->AsWeakPtr()));
+}
+
+FrameActivationInfo* ContentSubresourceFilterThrottleManager::
+    GetFrameActivationInfoForChildNavigation(
+        content::NavigationHandle* child_frame_navigation) {
+  DCHECK(!child_frame_navigation->IsInMainFrame());
+  content::RenderFrameHost* parent = web_contents()->FindFrameByFrameTreeNodeId(
+      child_frame_navigation->GetParentFrameTreeNodeId());
+  DCHECK(parent);
+  auto it = activated_frame_hosts_.find(parent);
+  return it == activated_frame_hosts_.end() ? nullptr : it->second.get();
+}
+
+VerifiedRuleset::Handle*
+ContentSubresourceFilterThrottleManager::EnsureRulesetHandle() {
+  if (!ruleset_handle_)
+    ruleset_handle_ = base::MakeUnique<VerifiedRuleset::Handle>(dealer_handle_);
+  return ruleset_handle_.get();
+}
+
+}  // namespace subresource_filter