Introduce AsyncDocumentSubresourceFilter.

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_forward.h"
+#include "base/macros.h"
+#include "base/optional.h"
+#include "base/sequenced_task_runner.h"
+#include "base/threading/thread_checker.h"
+#include "components/subresource_filter/content/browser/verified_ruleset_dealer.h"
+#include "components/subresource_filter/content/common/document_subresource_filter.h"
+#include "components/subresource_filter/core/common/activation_level.h"
+#include "components/subresource_filter/core/common/activation_state.h"
+#include "third_party/WebKit/public/platform/WebDocumentSubresourceFilter.h"
+
+namespace subresource_filter {
+
+// An asynchronous wrapper around DocumentSubresourceFilter.
+//
+// It is accessed on the UI thread and owns an ADSF::Core living on a dedicated

[engedy, 2017/02/14 15:13:13]

nit: Given that the existence of Core is an implementation details that clients
of this class might not necessarily be interested in, how about mentioning DSF
in client-facing comments?

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+// sequenced |task_runner|. Provides asynchronous access to the Core, and
+// destroys it asynchronously.
+class AsyncDocumentSubresourceFilter {
+ public:
+  using LoadPolicy = blink::WebDocumentSubresourceFilter::LoadPolicy;
+  using LoadPolicyCallback = base::Callback<void(LoadPolicy)>;
+
+  class Core;
+
+  // Parameters posted to ADSF::Core during its initialization. Needed for
+  // computing ActivationState for a (sub-)document, and for creating a

[engedy, 2017/02/14 15:13:14]

nit: I'd suggest swapping the two parts, so that the semantic meaning comes
first:

Encapsulates the parameters needed for computing the frame-level ActivationState
appropriate for the frame this ASDF is created for. These parameters are posted
to ADSF::Core during its initialization.

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+  // corresponding DocumentSubresourceFilter.
+  struct InitializationParams {
+    InitializationParams();
+
+    // Creates parameters for a main-frame |document|. |activation_level| should

[engedy, 2017/02/14 15:13:14]

nit: How about phrasing this an its sibling like so:

Takes parameters needed for calculating the main-frame ActivationState, that is:
the main-frame |document| URL, the page-level |activation_level|, and whether or
not to |measure_performance|.

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+    // not be DISABLED.
+    InitializationParams(GURL document_url,
+                         ActivationLevel activation_level,
+                         bool measure_performance);
+
+    // Creates parameters for a subframe |document|. Parent's |activation_state|
+    // should not be DISABLED.
+    InitializationParams(GURL document_url,
+                         url::Origin parent_document_origin,
+                         ActivationState parent_activation_state);
+
+    ~InitializationParams();
+
+    InitializationParams(InitializationParams&& other);
+    InitializationParams& operator=(InitializationParams&& other);
+
+    // Parameters used to compute ActivationState for the |document| before
+    // creating a DocumentSubresourceFilter.
+    GURL document_url;

[engedy, 2017/02/14 15:13:14]

nit: #include "url/gurl.h"

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+    url::Origin parent_document_origin;
+    ActivationState parent_activation_state;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(InitializationParams);
+  };
+
+  // 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 instance remains owned by |this| object, but lives on

[engedy, 2017/02/14 15:13:14]

nit: s/instance/core/

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+  // (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);
+
+  ~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();
+
+ private:
+  // 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::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilter);
+};
+
+// Holds a DocumentSubresourceFilter (after Initialization, in case there is a

[engedy, 2017/02/14 15:13:14]

Comment nit: 

// Holds a DocumentSubresourceFilter that is created in a deferred manner in
Initialize(), provided there is a valid ruleset to work with.

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+// valid MemoryMappedRuleset), and provides access to it.
+//
+// Initially holds an empty filter, allowing this object to be created on the

[engedy, 2017/02/14 15:13:14]

nit: What do you think about moving this paragraph (with minimal adjustments) to
the comment above the ASDF above, so that the reader is not left in suspense
wondering about the purpose of the Core?

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+// UI thread synchronously, hence letting the ADSF to be created synchronously
+// and be immediately used by clients on the UI thread, while the DSF is
+// retrieved on the |task_runner| in a deferred manner.
+class AsyncDocumentSubresourceFilter::Core {
+ public:
+  Core();
+  ~Core();
+
+  // Can return nullptr even after initialization in case MemoryMappedRuleset
+  // was not present, or was malformed during it.
+  DocumentSubresourceFilter* filter() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    return filter_ ? &filter_.value() : nullptr;
+  }
+
+ private:
+  friend class AsyncDocumentSubresourceFilter;
+
+  // Computes ActivationState from |params| and initializes a DSF using it.
+  // Returns the computed activation state.
+  ActivationState Initialize(InitializationParams params,
+                             VerifiedRuleset* verified_ruleset);
+
+  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_