Introduce AsyncDocumentSubresourceFilter.

components/subresource_filter/content/common/document_subresource_filter.cc

 // Copyright 2016 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/common/document_subresource_filter.h"
 
 #include <climits>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
@@ skipping 137 matching lines @@
       ruleset_matcher_(ruleset_->data(), ruleset_->length()),
       first_disallowed_load_callback_(
           std::move(first_disallowed_load_callback)) {
   DCHECK_NE(activation_state_.activation_level, ActivationLevel::DISABLED);
   if (!activation_state_.filtering_disabled_for_document)
     document_origin_.reset(new FirstPartyOrigin(std::move(document_origin)));
 }
 
 DocumentSubresourceFilter::~DocumentSubresourceFilter() = default;
 
-blink::WebDocumentSubresourceFilter::LoadPolicy
-DocumentSubresourceFilter::getLoadPolicy(
+DocumentSubresourceFilter::LoadPolicy DocumentSubresourceFilter::getLoadPolicy(
     const blink::WebURL& resourceUrl,
     blink::WebURLRequest::RequestContext request_context) {
   ++statistics_.num_loads_total;
 
   if (activation_state_.filtering_disabled_for_document)
-    return Allow;
+    return LoadPolicy::Allow;
   if (resourceUrl.protocolIs(url::kDataScheme))
-    return Allow;
+    return LoadPolicy::Allow;
 
   // TODO(pkalinnikov): Would be good to avoid converting to GURL.
   return EvaluateLoadPolicy(GURL(resourceUrl), ToElementType(request_context));
 }
 
-blink::WebDocumentSubresourceFilter::LoadPolicy
+DocumentSubresourceFilter::LoadPolicy
 DocumentSubresourceFilter::GetLoadPolicyForSubdocument(
     const GURL& subdocument_url) {
   ++statistics_.num_loads_total;
 
   if (activation_state_.filtering_disabled_for_document)
-    return Allow;
+    return LoadPolicy::Allow;
   if (subdocument_url.SchemeIs(url::kDataScheme))
-    return Allow;
+    return LoadPolicy::Allow;
   return EvaluateLoadPolicy(subdocument_url, proto::ELEMENT_TYPE_SUBDOCUMENT);
 }
 
 void DocumentSubresourceFilter::reportDisallowedLoad() {
   if (first_disallowed_load_callback_.is_null())
     return;
   std::move(first_disallowed_load_callback_).Run();
 }
 
-blink::WebDocumentSubresourceFilter::LoadPolicy
+DocumentSubresourceFilter::LoadPolicy
 DocumentSubresourceFilter::EvaluateLoadPolicy(const GURL& resource_url,
                                               proto::ElementType element_type) {
   TRACE_EVENT1("loader", "DocumentSubresourceFilter::EvaluateLoadPolicy", "url",
                resource_url.spec());
 
   auto wall_duration_timer = ScopedTimers::StartIf(
       activation_state_.measure_performance &&
           ScopedThreadTimers::IsSupported(),
       [this](base::TimeDelta delta) {
         statistics_.evaluation_total_wall_duration += delta;
         UMA_HISTOGRAM_MICRO_TIMES(
             "SubresourceFilter.SubresourceLoad.Evaluation.WallDuration", delta);
       });
   auto cpu_duration_timer = ScopedThreadTimers::StartIf(
       activation_state_.measure_performance, [this](base::TimeDelta delta) {
         statistics_.evaluation_total_cpu_duration += delta;
         UMA_HISTOGRAM_MICRO_TIMES(
             "SubresourceFilter.SubresourceLoad.Evaluation.CPUDuration", delta);
       });
 
   ++statistics_.num_loads_evaluated;
   DCHECK(document_origin_);
   if (ruleset_matcher_.ShouldDisallowResourceLoad(
           resource_url, *document_origin_, element_type,
           activation_state_.generic_blocking_rules_disabled)) {
     ++statistics_.num_loads_matching_rules;
     if (activation_state_.activation_level == ActivationLevel::ENABLED) {
       ++statistics_.num_loads_disallowed;
-      return Disallow;
+      return LoadPolicy::Disallow;
     } else if (activation_state_.activation_level == ActivationLevel::DRYRUN) {
-      return WouldDisallow;
+      return LoadPolicy::WouldDisallow;
     }
   }
-  return Allow;
+  return LoadPolicy::Allow;
 }
 
 }  // namespace subresource_filter