Introduce the ThrottleManager

components/subresource_filter/content/browser/async_document_subresource_filter.cc

 // 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/async_document_subresource_filter.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 35 matching lines @@
 InitializationParams::~InitializationParams() = default;
 InitializationParams::InitializationParams(InitializationParams&&) = default;
 InitializationParams& InitializationParams::operator=(InitializationParams&&) =
     default;
 
 // AsyncDocumentSubresourceFilter ----------------------------------------------
 
 AsyncDocumentSubresourceFilter::AsyncDocumentSubresourceFilter(
     VerifiedRuleset::Handle* ruleset_handle,
     InitializationParams params,
-    base::Callback<void(ActivationState)> activation_state_callback,
-    base::OnceClosure first_disallowed_load_callback)
+    base::Callback<void(ActivationState)> activation_state_callback)
     : task_runner_(ruleset_handle->task_runner()),
       core_(new Core(), base::OnTaskRunnerDeleter(task_runner_)),
-      first_disallowed_load_callback_(
-          std::move(first_disallowed_load_callback)) {
+      weak_ptr_factory_(this) {
   DCHECK_NE(ActivationLevel::DISABLED,
             params.parent_activation_state.activation_level);
 
   // Note: It is safe to post |ruleset_handle|'s VerifiedRuleset pointer,
   // because a task to delete it can only be posted to (and, therefore,
   // processed by) |task_runner| after this method returns, hence after the
   // below task is posted.
   base::PostTaskAndReplyWithResult(
       task_runner_, FROM_HERE,
       base::Bind(&Core::Initialize, base::Unretained(core_.get()),
                  base::Passed(&params), ruleset_handle->ruleset_.get()),
-      std::move(activation_state_callback));
+      base::Bind(&AsyncDocumentSubresourceFilter::OnActivateStateCalculated,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 std::move(activation_state_callback)));
 }
 
 AsyncDocumentSubresourceFilter::~AsyncDocumentSubresourceFilter() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
+void AsyncDocumentSubresourceFilter::OnActivateStateCalculated(
+    base::Callback<void(ActivationState)> activation_state_callback,
+    ActivationState activation_state) {
+  activation_state_ = activation_state;
+  activation_state_callback.Run(activation_state);
+}
+
 void AsyncDocumentSubresourceFilter::GetLoadPolicyForSubdocument(
     const GURL& subdocument_url,
     LoadPolicyCallback result_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(pkalinnikov): Think about avoiding copy of |subdocument_url| if it is
   // too big and won't be allowed anyway (e.g., it's a data: URI).
   base::PostTaskAndReplyWithResult(
       task_runner_, FROM_HERE,
       base::Bind(
@@ skipping 39 matching lines @@
       params.parent_activation_state, verified_ruleset->Get());
 
   DCHECK_NE(ActivationLevel::DISABLED, activation_state.activation_level);
   filter_.emplace(url::Origin(params.document_url), activation_state,
                   verified_ruleset->Get());
 
   return activation_state;
 }
 
 }  // namespace subresource_filter