Factor DocumentSubresourceFilter out of SubresourceFilterAgent.

components/subresource_filter/content/renderer/subresource_filter_agent.cc

Index: components/subresource_filter/content/renderer/subresource_filter_agent.cc
diff --git a/components/subresource_filter/content/renderer/subresource_filter_agent.cc b/components/subresource_filter/content/renderer/subresource_filter_agent.cc
index 4330a5e6e410e6c310e9d0139408cbc283d58168..b7b7ccae80c6b3d2058a53825b16d524d7ab75e5 100644
--- a/components/subresource_filter/content/renderer/subresource_filter_agent.cc
+++ b/components/subresource_filter/content/renderer/subresource_filter_agent.cc
@@ -4,65 +4,52 @@
 
 #include "components/subresource_filter/content/renderer/subresource_filter_agent.h"
 
-#include <climits>
-
+#include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
+#include "components/subresource_filter/content/renderer/document_subresource_filter.h"
 #include "components/subresource_filter/content/renderer/ruleset_dealer.h"
 #include "components/subresource_filter/core/common/memory_mapped_ruleset.h"
 #include "content/public/renderer/render_frame.h"
 #include "ipc/ipc_message.h"
-#include "third_party/WebKit/public/platform/WebDocumentSubresourceFilter.h"
-#include "third_party/WebKit/public/platform/WebURL.h"
-#include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "url/gurl.h"
 
 namespace subresource_filter {
 
-namespace {
-
-// Placeholder subresource filter implementation that treats the entire ruleset
-// as the UTF-8 representation of a string, and will disallow subresource loads
-// from URL paths having this string as a suffix.
-// TODO(engedy): Replace this with the actual filtering logic.
-class PathSuffixFilter : public blink::WebDocumentSubresourceFilter {
- public:
-  explicit PathSuffixFilter(const scoped_refptr<MemoryMappedRuleset>& ruleset)
-      : ruleset_(ruleset) {
-    static_assert(CHAR_BIT == 8, "Assumed char was 8 bits.");
-    disallowed_suffix_ = base::StringPiece(
-        reinterpret_cast<const char*>(ruleset_->data()), ruleset_->length());
-  }
-  ~PathSuffixFilter() override {}
-
-  bool allowLoad(const blink::WebURL& resourceUrl,
-                 blink::WebURLRequest::RequestContext) override {
-    return disallowed_suffix_.empty() ||
-           !base::EndsWith(GURL(resourceUrl).path(), disallowed_suffix_,
-                           base::CompareCase::SENSITIVE);
-  }
-
- private:
-  scoped_refptr<MemoryMappedRuleset> ruleset_;
-  base::StringPiece disallowed_suffix_;
-
-  DISALLOW_COPY_AND_ASSIGN(PathSuffixFilter);
-};
-
-}  // namespace
-
 SubresourceFilterAgent::SubresourceFilterAgent(
     content::RenderFrame* render_frame,
     RulesetDealer* ruleset_dealer)
     : content::RenderFrameObserver(render_frame),
       ruleset_dealer_(ruleset_dealer),
-      activation_state_for_provisional_load_(ActivationState::DISABLED) {}
+      activation_state_for_provisional_load_(ActivationState::DISABLED) {
+  DCHECK(ruleset_dealer);
+}
 
 SubresourceFilterAgent::~SubresourceFilterAgent() = default;
 
+std::vector<GURL> SubresourceFilterAgent::GetAncestorDocumentURLs() {
+  std::vector<GURL> urls;
+  for (blink::WebFrame* frame = render_frame()->GetWebFrame(); frame;
+       frame = frame->parent()) {
+    urls.push_back(frame->document().url());
+  }
+  return urls;
+}
+
+void SubresourceFilterAgent::SetSubresourceFilterForCommittedLoad(
+    std::unique_ptr<blink::WebDocumentSubresourceFilter> filter) {
+  blink::WebLocalFrame* web_frame = render_frame()->GetWebFrame();
+  web_frame->dataSource()->setSubresourceFilter(filter.release());
+}
+
+void SubresourceFilterAgent::ActivateForProvisionalLoad(
+    ActivationState activation_state) {
+  activation_state_for_provisional_load_ = activation_state;
+}
+
 void SubresourceFilterAgent::OnDestruct() {
   delete this;
 }
@@ -74,27 +61,26 @@ void SubresourceFilterAgent::DidStartProvisionalLoad() {
 void SubresourceFilterAgent::DidCommitProvisionalLoad(
     bool is_new_navigation,
     bool is_same_page_navigation) {
-  if (activation_state_for_provisional_load_ == ActivationState::ENABLED &&
+  if (activation_state_for_provisional_load_ != ActivationState::DISABLED &&
       ruleset_dealer_->ruleset()) {
-    blink::WebLocalFrame* web_frame = render_frame()->GetWebFrame();
-    web_frame->dataSource()->setSubresourceFilter(
-        new PathSuffixFilter(ruleset_dealer_->ruleset()));
+    std::vector<GURL> ancestor_document_urls = GetAncestorDocumentURLs();
+    std::unique_ptr<DocumentSubresourceFilter> filter(
+        new DocumentSubresourceFilter(activation_state_for_provisional_load_,
+                                      ruleset_dealer_->ruleset(),
+                                      std::move(ancestor_document_urls)));
+    SetSubresourceFilterForCommittedLoad(std::move(filter));
   }
+  activation_state_for_provisional_load_ = ActivationState::DISABLED;
 }
 
 bool SubresourceFilterAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SubresourceFilterAgent, message)
     IPC_MESSAGE_HANDLER(SubresourceFilterMsg_ActivateForProvisionalLoad,
-                        OnActivateForProvisionalLoad)
+                        ActivateForProvisionalLoad)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void SubresourceFilterAgent::OnActivateForProvisionalLoad(
-    ActivationState activation_state) {
-  activation_state_for_provisional_load_ = activation_state;
-}
-
 }  // namespace subresource_filter