Introduce the ThrottleManager

components/subresource_filter/content/browser/async_document_subresource_filter.h

 // 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.
 
 #ifndef COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_ASYNC_DOCUMENT_SUBRESOURCE_FILTER_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_ASYNC_DOCUMENT_SUBRESOURCE_FILTER_H_
 
 #include <memory>
 
 #include "base/callback.h"
@@ skipping 64 matching lines @@
   // Creates a Core and initializes it asynchronously on a |task_runner| using
   // the supplied initialization |params| and a VerifiedRuleset taken from the
   // |ruleset_handle|. The core remains owned by |this| object, but lives on
   // (and is accessed on) the |task_runner|.
   //
   // Once the ActivationState for the current frame is calculated, it is
   // reported back via |activation_state_callback| on the task runner associated
   // with the current thread. If MemoryMappedRuleset is not present or
   // malformed, then a default ActivationState is reported (with ActivationLevel
   // equal to DISABLED).
-  //
-  // The |first_disallowed_load_callback|, if it is non-null, is invoked on the
-  // first ReportDisallowedLoad() call.
   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);
 
   ~AsyncDocumentSubresourceFilter();
 
   // Computes LoadPolicy on a |task_runner| and returns it back to the calling
   // thread via |result_callback|. If MemoryMappedRuleset is not present or
   // malformed, then a LoadPolicy::Allow is returned.
   void GetLoadPolicyForSubdocument(const GURL& subdocument_url,
                                    LoadPolicyCallback result_callback);
 
   // Invokes |first_disallowed_load_callback|, if necessary, and posts a task to
   // call DocumentSubresourceFilter::reportDisallowedCallback() on the
   // |task_runner|.
   void ReportDisallowedLoad();
 
+  // Must be called after activation state computation is finished.
+  const ActivationState& activation_state() const {
+    return activation_state_.value();
+  }
+
+  // The |first_disallowed_load_callback|, if it is non-null, is invoked on the
+  // first ReportDisallowedLoad() call.
+  void set_first_disallowed_load_callback(base::OnceClosure callback) {
+    first_disallowed_load_callback_ = std::move(callback);
+  }
+
  private:
+  void OnActivateStateCalculated(
+      base::Callback<void(ActivationState)> activation_state_callback,
+      ActivationState activation_state);
+
   // Note: Raw pointer, |core_| already holds a reference to |task_runner_|.
   base::SequencedTaskRunner* task_runner_;
   std::unique_ptr<Core, base::OnTaskRunnerDeleter> core_;
   base::OnceClosure first_disallowed_load_callback_;
 
+  base::Optional<ActivationState> activation_state_;
+
   base::ThreadChecker thread_checker_;
 
+  base::WeakPtrFactory<AsyncDocumentSubresourceFilter> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilter);
 };
 
 // Holds a DocumentSubresourceFilter that is created in a deferred manner in
 // Initialize(), provided there is a valid ruleset to work with.
 class AsyncDocumentSubresourceFilter::Core {
  public:
   Core();
   ~Core();
 
@@ skipping 14 matching lines @@
 
   base::Optional<DocumentSubresourceFilter> filter_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CONTENT_BROWSER_ASYNC_DOCUMENT_SUBRESOURCE_FILTER_H_