Encapsulate CSS selector declarative content condition tracking

This is the first step in a refactoring of the declarativeContent API
implementation. The goal is to facilitate profile state matching by
providing abstractions for conditions and condition state tracking
and evaluation.

This CL consists of steps 1 and 2 described in the associated bug:
by-hand instantiation of DeclarativeRule as DeclarativeContentRule to
decouple changes from the web request declarative API implementation,
and encapsulation of CSS selector condition tracking logic. No
functional change is intended.

BUG=492946

Review URL: https://codereview.chromium.org/1159733004

Cr-Commit-Position: refs/heads/master@{#333144}

chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.h

@@ -16,6 +16,7 @@
 #include "base/time/time.h"
 #include "chrome/browser/extensions/api/declarative_content/content_action.h"
 #include "chrome/browser/extensions/api/declarative_content/content_condition.h"
+#include "chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h"
 #include "components/url_matcher/url_matcher.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
@@ -66,20 +67,17 @@ typedef DeclarativeRule<ContentCondition, ContentAction> ContentRule;
 // side of split-mode extensions to incognito tabs. The non-incognito instance
 // handles incognito tabs for spanning-mode extensions, plus all non-incognito
 // tabs.
-class ChromeContentRulesRegistry : public ContentRulesRegistry,
-                                   public content::NotificationObserver {
+class ChromeContentRulesRegistry
+    : public ContentRulesRegistry,
+      public content::NotificationObserver,
+      public DeclarativeContentCssConditionTrackerDelegate {
  public:
   // For testing, |ui_part| can be NULL. In that case it constructs the
   // registry with storage functionality suspended.
   ChromeContentRulesRegistry(content::BrowserContext* browser_context,
                              RulesCacheDelegate* cache_delegate);
 
-  // ChromeContentRulesRegistry implementation:
-  // Applies all content rules given an update (CSS match change or
-  // page navigation, for now) from the renderer.
-  void Apply(content::WebContents* contents,
-             const std::vector<std::string>& matching_css_selectors) override;
-
+  // ContentRulesRegistry:
   // Applies all content rules given that a tab was just navigated.
   void DidNavigateMainFrame(
       content::WebContents* tab,
@@ -94,7 +92,7 @@ class ChromeContentRulesRegistry : public ContentRulesRegistry,
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override;
 
-  // Implementation of RulesRegistry:
+  // RulesRegistry:
   std::string AddRulesImpl(
       const std::string& extension_id,
       const std::vector<linked_ptr<RulesRegistry::Rule>>& rules) override;
@@ -103,14 +101,31 @@ class ChromeContentRulesRegistry : public ContentRulesRegistry,
       const std::vector<std::string>& rule_identifiers) override;
   std::string RemoveAllRulesImpl(const std::string& extension_id) override;
 
-  // content::NotificationObserver implementation.
+  // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
+  // DeclarativeContentCssConditionTrackerDelegate:
+  void RequestEvaluation(content::WebContents* contents) override;
+  bool ShouldManageConditionsForBrowserContext(
+      content::BrowserContext* context) override;
+
   // Returns true if this object retains no allocated data. Only for debugging.
   bool IsEmpty() const;
 
+  // TODO(wittman): Remove once DeclarativeChromeContentRulesRegistry no longer
+  // depends on concrete condition implementations. At that point
+  // DeclarativeChromeContentRulesRegistryTest.ActiveRulesDoesntGrow will be
+  // able to use a test condition object and not need to depend on force setting
+  // matching CSS seleectors.
+  void UpdateMatchingCssSelectorsForTesting(
+      content::WebContents* contents,
+      const std::vector<std::string>& matching_css_selectors);
+
+  // Returns the number of active rules.
+  size_t GetActiveRulesCountForTesting();
+
  protected:
   ~ChromeContentRulesRegistry() override;
 
@@ -119,27 +134,22 @@ class ChromeContentRulesRegistry : public ContentRulesRegistry,
       const std::string& extension_id) const;
 
  private:
-  friend class DeclarativeChromeContentRulesRegistryTest;
+  // Utility function for iterating a lambda over the relevant WebContents.
+  template <class Func>
+  void ForEachWebContents(const Func& func);
+
+  // Set up the state to track rules for |contents|.
+  void TrackRulesForWebContents(content::WebContents* contents);
 
   // True if this object is managing the rules for |context|.
   bool ManagingRulesForBrowserContext(content::BrowserContext* context);
 
-  // Applies all content rules given that a tab was just navigated.
-  void OnTabNavigation(content::WebContents* tab, bool is_in_page_navigation);
-
   std::set<const ContentRule*> GetMatches(
       const RendererContentMatchData& renderer_data,
       bool is_incognito_renderer) const;
 
-  // Scans the rules for the set of conditions they're watching.  If the set has
-  // changed, calls InstructRenderProcess() for each RenderProcessHost in the
-  // current browser_context.
-  void UpdateConditionCache();
-
-  // If the renderer process is associated with our browser context, tells it
-  // what page attributes to watch for using an ExtensionMsg_WatchPages.
-  void InstructRenderProcessIfSameBrowserContext(
-      content::RenderProcessHost* process);
+  // Updates the condition evaluator with the current watched CSS selectors.
+  void UpdateCssSelectorsFromRules();
 
   // Evaluates the conditions for |tab| based on the tab state and matching CSS
   // selectors.
@@ -152,8 +162,6 @@ class ChromeContentRulesRegistry : public ContentRulesRegistry,
       URLMatcherIdToRule;
   typedef std::map<ContentRule::GlobalRuleId, linked_ptr<const ContentRule>>
       RulesMap;
-  typedef std::map<content::WebContents*, std::vector<std::string>>
-      CssSelectors;
 
   // Map that tells us which ContentRules may match under the condition that
   // the URLMatcherConditionSet::ID was returned by the |url_matcher_|.
@@ -162,23 +170,22 @@ class ChromeContentRulesRegistry : public ContentRulesRegistry,
   RulesMap content_rules_;
 
   // Maps a WebContents to the set of rules that match on that WebContents.
-  // This lets us call Revert as appropriate.
+  // This lets us call Revert as appropriate. Note that this is expected to have
+  // a key-value pair for every WebContents the registry is tracking, even if
+  // the value is the empty set.
   std::map<content::WebContents*, std::set<const ContentRule*>> active_rules_;
 
   // Matches URLs for the page_url condition.
   url_matcher::URLMatcher url_matcher_;
 
-  // All CSS selectors any rule's conditions watch for.
-  std::vector<std::string> watched_css_selectors_;
+  // Responsible for evaluating the declarative content conditions.
+  DeclarativeContentCssConditionTracker css_condition_tracker_;
 
   // Manages our notification registrations.
   content::NotificationRegistrar registrar_;
 
   scoped_refptr<InfoMap> extension_info_map_;
 
-  // Maps tab_id to the matching CSS selectors for the tab.
-  CssSelectors matching_css_selectors_;
-
   DISALLOW_COPY_AND_ASSIGN(ChromeContentRulesRegistry);
 };
 

chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc

@@ -7,10 +7,12 @@
 #include <string>
 
 #include "base/test/values_test_util.h"
-#include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/navigation_details.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -18,42 +20,27 @@
 
 namespace extensions {
 
-using base::test::ParseJson;
-using testing::HasSubstr;
-using content::WebContents;
-
-// Must be outside the anonymous namespace to be a friend of
-// ContentRulesRegistry.
-class DeclarativeChromeContentRulesRegistryTest : public testing::Test {
- protected:
-  using RulesMap =
-      std::map<content::WebContents*, std::set<const ContentRule*>>;
-  static const RulesMap& active_rules(
-      const ChromeContentRulesRegistry& registry) {
-    return registry.active_rules_;
-  }
-};
-
-namespace {
-
-TEST_F(DeclarativeChromeContentRulesRegistryTest, ActiveRulesDoesntGrow) {
+TEST(DeclarativeChromeContentRulesRegistryTest, ActiveRulesDoesntGrow) {
   TestExtensionEnvironment env;
 
   scoped_refptr<ChromeContentRulesRegistry> registry(
       new ChromeContentRulesRegistry(env.profile(), NULL));
 
-  EXPECT_EQ(0u, active_rules(*registry.get()).size());
+  EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
-  content::LoadCommittedDetails load_details;
-  content::FrameNavigateParams navigate_params;
-  scoped_ptr<WebContents> tab = env.MakeTab();
-  registry->DidNavigateMainFrame(tab.get(), load_details, navigate_params);
-  EXPECT_EQ(0u, active_rules(*registry.get()).size());
+  scoped_ptr<content::WebContents> tab = env.MakeTab();
+  // Let the registry know about the tab.
+  registry->Observe(chrome::NOTIFICATION_TAB_ADDED,
+                    content::Source<content::WebContentsDelegate>(nullptr),
+                    content::Details<content::WebContents>(tab.get()));
+  registry->DidNavigateMainFrame(tab.get(), content::LoadCommittedDetails(),
+                                 content::FrameNavigateParams());
+  EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
   // Add a rule.
   linked_ptr<RulesRegistry::Rule> rule(new RulesRegistry::Rule);
   RulesRegistry::Rule::Populate(
-      *ParseJson(
+      *base::test::ParseJson(
           "{\n"
           "  \"id\": \"rule1\",\n"
           "  \"priority\": 100,\n"
@@ -70,30 +57,35 @@ TEST_F(DeclarativeChromeContentRulesRegistryTest, ActiveRulesDoesntGrow) {
   std::vector<linked_ptr<RulesRegistry::Rule> > rules;
   rules.push_back(rule);
 
-  const Extension* extension = env.MakeExtension(*ParseJson(
+  const Extension* extension = env.MakeExtension(*base::test::ParseJson(
       "{\"page_action\": {}}"));
   registry->AddRulesImpl(extension->id(), rules);
 
-  registry->DidNavigateMainFrame(tab.get(), load_details, navigate_params);
-  EXPECT_EQ(0u, active_rules(*registry.get()).size());
+  registry->DidNavigateMainFrame(tab.get(), content::LoadCommittedDetails(),
+                                 content::FrameNavigateParams());
+  EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
   std::vector<std::string> css_selectors;
   css_selectors.push_back("input");
-  registry->Apply(tab.get(), css_selectors);
-  EXPECT_EQ(1u, active_rules(*registry.get()).size());
+  registry->UpdateMatchingCssSelectorsForTesting(tab.get(), css_selectors);
+  EXPECT_EQ(1u, registry->GetActiveRulesCountForTesting());
 
   // Closing the tab should erase its entry from active_rules_.
   tab.reset();
-  EXPECT_EQ(0u, active_rules(*registry.get()).size());
+  EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 
   tab = env.MakeTab();
-  registry->Apply(tab.get(), css_selectors);
-  EXPECT_EQ(1u, active_rules(*registry.get()).size());
+  // Let the registry know about the tab.
+  registry->Observe(chrome::NOTIFICATION_TAB_ADDED,
+                    content::Source<content::WebContentsDelegate>(nullptr),
+                    content::Details<content::WebContents>(tab.get()));
+  registry->UpdateMatchingCssSelectorsForTesting(tab.get(), css_selectors);
+  EXPECT_EQ(1u, registry->GetActiveRulesCountForTesting());
   // Navigating the tab should erase its entry from active_rules_ if
   // it no longer matches.
-  registry->DidNavigateMainFrame(tab.get(), load_details, navigate_params);
-  EXPECT_EQ(0u, active_rules(*registry.get()).size());
+  registry->DidNavigateMainFrame(tab.get(), content::LoadCommittedDetails(),
+                                 content::FrameNavigateParams());
+  EXPECT_EQ(0u, registry->GetActiveRulesCountForTesting());
 }
 
-}  // namespace
 }  // namespace extensions

chrome/browser/extensions/api/declarative_content/content_action.h

@@ -16,6 +16,7 @@
 namespace base {
 class Time;
 class Value;
+class DictionaryValue;
 }
 
 namespace content {

chrome/browser/extensions/api/declarative_content/content_condition.h

@@ -5,7 +5,6 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_CONTENT_CONDITION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_CONTENT_CONDITION_H_
 
-#include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ -13,12 +12,17 @@
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/values.h"
 #include "components/url_matcher/url_matcher.h"
 #include "extensions/browser/api/declarative/declarative_rule.h"
 
+namespace base {
+class Value;
+}
+
 namespace extensions {
 
+class Extension;
+
 struct RendererContentMatchData {
   RendererContentMatchData();
   ~RendererContentMatchData();

chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.cc

+// Copyright 2015 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 "chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h"
+
+#include <algorithm>
+
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/render_process_host.h"
+#include "extensions/common/extension_messages.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
+
+namespace extensions {
+
+//
+// PerWebContentsTracker
+//
+
+// Monitors CSS selector matching state on one WebContents.
+class DeclarativeContentCssConditionTracker::
+      PerWebContentsTracker : public content::WebContentsObserver {
+ public:
+  using RequestEvaluationCallback =
+      DeclarativeContentCssConditionTrackerDelegate::WebContentsCallback;
+  using DestroyingCallback =
+      base::Callback<void(PerWebContentsTracker*)>;
+
+  PerWebContentsTracker(
+      content::WebContents* contents,
+      const RequestEvaluationCallback& request_evaluation,
+      const DestroyingCallback& destroying);
+  ~PerWebContentsTracker() override;
+
+  void OnWebContentsNavigation(const content::LoadCommittedDetails& details,
+                               const content::FrameNavigateParams& params);
+
+  // See comment on similar function above.
+  void UpdateMatchingCssSelectorsForTesting(
+      const std::vector<std::string>& matching_css_selectors);
+
+  const std::vector<std::string>& matching_css_selectors() const {
+    return matching_css_selectors_;
+  }
+
+ private:
+  // content::WebContentsObserver overrides.
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void WebContentsDestroyed() override;
+
+  void OnWatchedPageChange(const std::vector<std::string>& css_selectors);
+
+  const RequestEvaluationCallback request_evaluation_;
+  const DestroyingCallback destroying_;
+
+  std::vector<std::string> matching_css_selectors_;
+
+  DISALLOW_COPY_AND_ASSIGN(PerWebContentsTracker);
+};
+
+DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+PerWebContentsTracker(
+    content::WebContents* contents,
+    const RequestEvaluationCallback& request_evaluation,
+    const DestroyingCallback& destroying)
+    : WebContentsObserver(contents),
+      request_evaluation_(request_evaluation),
+      destroying_(destroying) {
+}
+
+DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+~PerWebContentsTracker() {
+}
+
+void DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+OnWebContentsNavigation(const content::LoadCommittedDetails& details,
+                        const content::FrameNavigateParams& params) {
+  if (details.is_in_page) {
+    // Within-page navigations don't change the set of elements that
+    // exist, and we only support filtering on the top-level URL, so
+    // this can't change which rules match.
+    return;
+  }
+
+  // Top-level navigation produces a new document. Initially, the
+  // document's empty, so no CSS rules match.  The renderer will send
+  // an ExtensionHostMsg_OnWatchedPageChange later if any CSS rules
+  // match.
+  matching_css_selectors_.clear();
+  request_evaluation_.Run(web_contents());
+}
+
+void DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+UpdateMatchingCssSelectorsForTesting(
+    const std::vector<std::string>& matching_css_selectors) {
+  matching_css_selectors_ = matching_css_selectors;
+  request_evaluation_.Run(web_contents());
+}
+
+bool
+DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PerWebContentsTracker, message)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OnWatchedPageChange,
+                        OnWatchedPageChange)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+WebContentsDestroyed() {
+  destroying_.Run(this);
+  delete this;
+}
+
+void
+DeclarativeContentCssConditionTracker::PerWebContentsTracker::
+OnWatchedPageChange(
+    const std::vector<std::string>& css_selectors) {
+  matching_css_selectors_ = css_selectors;
+  request_evaluation_.Run(web_contents());
+}
+
+//
+// DeclarativeContentCssConditionTrackerDelegate
+//
+
+DeclarativeContentCssConditionTrackerDelegate::
+DeclarativeContentCssConditionTrackerDelegate() {}
+
+DeclarativeContentCssConditionTrackerDelegate::
+~DeclarativeContentCssConditionTrackerDelegate() {}
+
+//
+// DeclarativeContentCssConditionTracker
+//
+
+DeclarativeContentCssConditionTracker::DeclarativeContentCssConditionTracker(
+    content::BrowserContext* context,
+    DeclarativeContentCssConditionTrackerDelegate* delegate)
+    : context_(context),
+      delegate_(delegate) {
+  registrar_.Add(this,
+                 content::NOTIFICATION_RENDERER_PROCESS_CREATED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+}
+
+DeclarativeContentCssConditionTracker::
+~DeclarativeContentCssConditionTracker() {
+  // All monitored WebContents are expected to be destroyed before this object.
+  CHECK(per_web_contents_tracker_.empty());
+}
+
+// We use the sorted propery of the set for equality checks with
+// watched_css_selectors_, which is guaranteed to be sorted because it's set
+// from the set contents.
+void DeclarativeContentCssConditionTracker::SetWatchedCssSelectors(
+    const std::set<std::string>& new_watched_css_selectors) {
+  if (new_watched_css_selectors.size() != watched_css_selectors_.size() ||
+      !std::equal(new_watched_css_selectors.begin(),
+                  new_watched_css_selectors.end(),
+                  watched_css_selectors_.begin())) {
+    watched_css_selectors_.assign(new_watched_css_selectors.begin(),
+                                  new_watched_css_selectors.end());
+
+    for (content::RenderProcessHost::iterator it(
+             content::RenderProcessHost::AllHostsIterator());
+         !it.IsAtEnd();
+         it.Advance()) {
+      InstructRenderProcessIfManagingBrowserContext(it.GetCurrentValue());
+    }
+  }
+}
+
+void DeclarativeContentCssConditionTracker::TrackForWebContents(
+    content::WebContents* contents) {
+  CreatePerWebContentsTracker(contents);
+}
+
+void DeclarativeContentCssConditionTracker::OnWebContentsNavigation(
+    content::WebContents* contents,
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  per_web_contents_tracker_[contents]->OnWebContentsNavigation(details, params);
+}
+
+void DeclarativeContentCssConditionTracker::GetMatchingCssSelectors(
+    content::WebContents* contents,
+    base::hash_set<std::string>* css_selectors) {
+  const std::vector<std::string>& matching_css_selectors =
+      per_web_contents_tracker_[contents]->matching_css_selectors();
+  css_selectors->insert(matching_css_selectors.begin(),
+                        matching_css_selectors.end());
+}
+
+void DeclarativeContentCssConditionTracker::
+UpdateMatchingCssSelectorsForTesting(
+    content::WebContents* contents,
+    const std::vector<std::string>& matching_css_selectors) {
+  per_web_contents_tracker_[contents]->
+      UpdateMatchingCssSelectorsForTesting(matching_css_selectors);
+}
+
+void DeclarativeContentCssConditionTracker::CreatePerWebContentsTracker(
+    content::WebContents* contents) {
+  // This is a weak pointer; PerWebContentsTracker owns itself.
+  per_web_contents_tracker_[contents] =
+      new PerWebContentsTracker(
+          contents,
+          base::Bind(&DeclarativeContentCssConditionTrackerDelegate::
+                     RequestEvaluation,
+                     base::Unretained(delegate_)),
+          base::Bind(&DeclarativeContentCssConditionTracker::
+                     RemovePerWebContentsTracker,
+                     base::Unretained(this)));
+}
+
+void DeclarativeContentCssConditionTracker::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
+      content::RenderProcessHost* process =
+          content::Source<content::RenderProcessHost>(source).ptr();
+      InstructRenderProcessIfManagingBrowserContext(process);
+      break;
+    }
+  }
+}
+
+void DeclarativeContentCssConditionTracker::
+InstructRenderProcessIfManagingBrowserContext(
+    content::RenderProcessHost* process) {
+  if (delegate_->ShouldManageConditionsForBrowserContext(
+          process->GetBrowserContext())) {
+    process->Send(new ExtensionMsg_WatchPages(watched_css_selectors_));
+  }
+}
+
+void DeclarativeContentCssConditionTracker::RemovePerWebContentsTracker(
+    PerWebContentsTracker* tracker) {
+  per_web_contents_tracker_.erase(tracker->web_contents());
+}
+
+}  // namespace extensions

chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h

+// Copyright 2015 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 CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_DECLARATIVE_CONTENT_CSS_CONDITION_TRACKER_H_
+#define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_DECLARATIVE_CONTENT_CSS_CONDITION_TRACKER_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/containers/hash_tables.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/web_contents_observer.h"
+
+
+namespace content {
+class BrowserContext;
+struct FrameNavigateParams;
+struct LoadCommittedDetails;
+class RenderProcessHost;
+class WebContents;
+}
+
+namespace extensions {
+
+// Interface that allows the DeclarativeContentCssConditionTracker to request
+// condition evaluation, and shields it from having to know about Browsers.
+class DeclarativeContentCssConditionTrackerDelegate {
+ public:
+  // Callback for per-tab invocations.
+  using WebContentsCallback =
+      base::Callback<void(content::WebContents* content)>;
+
+  // Requests re-evaluation of conditions for |contents|.
+  virtual void RequestEvaluation(content::WebContents* contents) = 0;
+
+  // Returns true if the evaluator should manage condition state for |context|.
+  virtual bool ShouldManageConditionsForBrowserContext(
+      content::BrowserContext* context) = 0;
+
+ protected:
+  DeclarativeContentCssConditionTrackerDelegate();
+  virtual ~DeclarativeContentCssConditionTrackerDelegate();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeclarativeContentCssConditionTrackerDelegate);
+};
+
+// Supports watching of CSS selectors to across tab contents in a browser
+// context, and querying for the matching CSS selectors for a context.
+class DeclarativeContentCssConditionTracker
+    : public content::NotificationObserver {
+ public:
+  DeclarativeContentCssConditionTracker(
+      content::BrowserContext* context,
+      DeclarativeContentCssConditionTrackerDelegate* delegate);
+  ~DeclarativeContentCssConditionTracker() override;
+
+  // Sets the set of CSS selectors to watch for CSS condition evaluation.
+  void SetWatchedCssSelectors(
+      const std::set<std::string>& watched_css_selectors);
+
+  // Requests that CSS conditions be tracked for |contents|.
+  void TrackForWebContents(content::WebContents* contents);
+
+  // Handles navigation of |contents|. We depend on the caller to notify us of
+  // this event rather than listening for it ourselves, so that the caller can
+  // coordinate evaluation with all the trackers that respond to it. If we
+  // listened ourselves and requested rule evaluation before another tracker
+  // received the notification, our conditions would be evaluated based on the
+  // new URL while the other tracker's conditions would still be evaluated based
+  // on the previous URL.
+  void OnWebContentsNavigation(content::WebContents* contents,
+                               const content::LoadCommittedDetails& details,
+                               const content::FrameNavigateParams& params);
+
+  // Inserts the currently-matching CSS selectors into |css_selectors|. We use
+  // hash_set for maximally efficient lookup.
+  void GetMatchingCssSelectors(content::WebContents* contents,
+                               base::hash_set<std::string>* css_selectors);
+
+  // TODO(wittman): Remove once DeclarativeChromeContentRulesRegistry no longer
+  // depends on concrete condition implementations. At that point
+  // DeclarativeChromeContentRulesRegistryTest.ActiveRulesDoesntGrow will be
+  // able to use a test condition object and not need to depend on force setting
+  // matching CSS seleectors.
+  void UpdateMatchingCssSelectorsForTesting(
+      content::WebContents* contents,
+      const std::vector<std::string>& matching_css_selectors);
+
+ private:
+  class PerWebContentsTracker;
+
+  // Instantiate a PerWebContentsTracker watching |contents|.
+  void CreatePerWebContentsTracker(content::WebContents* contents);
+
+  // content::NotificationObserver implementation.
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override;
+
+  // If the renderer process is associated with our browser context, tells it
+  // what page attributes to watch for using an ExtensionMsg_WatchPages.
+  void InstructRenderProcessIfManagingBrowserContext(
+      content::RenderProcessHost* process);
+
+  // Called by PerWebContentsTracker on destruction.
+  void RemovePerWebContentsTracker(PerWebContentsTracker* tracker);
+
+  // The context whose state we're monitoring for evaluation.
+  content::BrowserContext* context_;
+
+  // All CSS selectors that are watched for by any rule's conditions. This
+  // vector is sorted by construction.
+  std::vector<std::string> watched_css_selectors_;
+
+  // Maps WebContents to the tracker for that WebContents
+  // state. PerWebContentsTracker owns itself, so this pointer is weak.
+  std::map<content::WebContents*, PerWebContentsTracker*>
+      per_web_contents_tracker_;
+
+  // Weak.
+  DeclarativeContentCssConditionTrackerDelegate* delegate_;
+
+  // Manages our notification registrations.
+  content::NotificationRegistrar registrar_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeclarativeContentCssConditionTracker);
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_CONTENT_DECLARATIVE_CONTENT_CSS_CONDITION_TRACKER_H_

chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker_unittest.cc

+// Copyright 2015 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 "chrome/browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/run_loop.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_renderer_host.h"
+#include "content/public/test/web_contents_tester.h"
+#include "extensions/common/extension_messages.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+
+using testing::UnorderedElementsAreArray;
+
+class DeclarativeContentCssConditionTrackerTest : public testing::Test {
+ public:
+  DeclarativeContentCssConditionTrackerTest()
+      : profile_(new TestingProfile),
+        delegate_(web_contents_) {
+  }
+
+  ~DeclarativeContentCssConditionTrackerTest() override {
+    web_contents_.clear();
+    // MockRenderProcessHosts are deleted from the message loop, and their
+    // deletion must complete before RenderViewHostTestEnabler's destructor is
+    // run.
+    base::RunLoop().RunUntilIdle();
+  }
+
+ protected:
+  class Delegate : public DeclarativeContentCssConditionTrackerDelegate {
+   public:
+    Delegate(const ScopedVector<content::WebContents>& web_contents)
+        : web_contents_(web_contents),
+          evaluation_requests_(0) {
+    }
+
+    int evaluation_requests() { return evaluation_requests_; }
+
+    // DeclarativeContentCssConditionTrackerDelegate:
+    void RequestEvaluation(content::WebContents* contents) override {
+      ++evaluation_requests_;
+    }
+
+    bool ShouldManageConditionsForBrowserContext(
+        content::BrowserContext* context) override {
+      return true;
+    }
+
+   private:
+    // Reference to the test's WebContents vector.
+    const ScopedVector<content::WebContents>& web_contents_;
+    int evaluation_requests_;
+
+    DISALLOW_COPY_AND_ASSIGN(Delegate);
+  };
+
+  // Creates a new DeclarativeContentCssConditionTracker and retains ownership.
+  DeclarativeContentCssConditionTracker* MakeTracker() {
+    trackers_.push_back(
+        new DeclarativeContentCssConditionTracker(profile(), delegate()));
+    return trackers_.back();
+  }
+
+  // Creates a new WebContents and retains ownership.
+  content::WebContents* MakeTab() {
+    web_contents_.push_back(
+        content::WebContentsTester::CreateTestWebContents(profile_.get(),
+                                                          nullptr));
+    return web_contents_.back();
+  }
+
+  // Expect an ExtensionMsg_WatchPages message in |sink| with |selectors| as the
+  // param, after invoking |func|.
+  template <class Func>
+  void ExpectWatchPagesMessage(IPC::TestSink& sink,
+                               const std::set<std::string>& selectors,
+                               const Func& func) {
+    sink.ClearMessages();
+    func();
+    EXPECT_EQ(1u, sink.message_count());
+    const IPC::Message* message =
+        sink.GetUniqueMessageMatching(ExtensionMsg_WatchPages::ID);
+    ASSERT_TRUE(message);
+    ExtensionMsg_WatchPages::Param params;
+    ExtensionMsg_WatchPages::Read(message, &params);
+    EXPECT_THAT(base::get<0>(params), UnorderedElementsAreArray(selectors));
+  }
+
+  // Sends an OnWatchedPageChange message to the tab.
+  void SendOnWatchedPageChangeMessage(
+      content::WebContents* tab,
+      const std::vector<std::string>& selectors) {
+    ExtensionHostMsg_OnWatchedPageChange page_change(tab->GetRoutingID(),
+                                                     selectors);
+    content::MockRenderProcessHost* process =
+        static_cast<content::MockRenderProcessHost*>(
+            tab->GetRenderViewHost()->GetProcess());
+
+    EXPECT_TRUE(process->OnMessageReceived(page_change));
+  }
+
+  Profile* profile() { return profile_.get(); }
+  Delegate* delegate() { return &delegate_; }
+
+ private:
+  content::TestBrowserThreadBundle thread_bundle_;
+
+  // Enables MockRenderProcessHosts.
+  content::RenderViewHostTestEnabler render_view_host_test_enabler_;
+
+  const scoped_ptr<TestingProfile> profile_;
+  ScopedVector<DeclarativeContentCssConditionTracker> trackers_;
+  ScopedVector<content::WebContents> web_contents_;
+  Delegate delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeclarativeContentCssConditionTrackerTest);
+};
+
+// Tests the basic flow of operations on the
+// DeclarativeContentCssConditionTracker.
+TEST_F(DeclarativeContentCssConditionTrackerTest, Basic) {
+  DeclarativeContentCssConditionTracker *tracker = MakeTracker();
+  int expected_evaluation_requests = 0;
+
+  content::WebContents* const tab = MakeTab();
+  tracker->TrackForWebContents(tab);
+  EXPECT_EQ(expected_evaluation_requests, delegate()->evaluation_requests());
+
+  content::MockRenderProcessHost* process =
+          static_cast<content::MockRenderProcessHost*>(
+              tab->GetRenderViewHost()->GetProcess());
+
+  // Check that calling SetWatchedCssSelectors sends a WatchPages message with
+  // the selectors to the tab's RenderProcessHost.
+  std::set<std::string> watched_selectors;
+  watched_selectors.insert("a");
+  watched_selectors.insert("div");
+  ExpectWatchPagesMessage(process->sink(), watched_selectors,
+                          [&tracker, &watched_selectors]() {
+    tracker->SetWatchedCssSelectors(watched_selectors);
+  });
+  EXPECT_EQ(expected_evaluation_requests, delegate()->evaluation_requests());
+
+  // Check that receiving an OnWatchedPageChange message from the tab results in
+  // a request for condition evaluation.
+  const std::vector<std::string> matched_selectors(1, "div");
+  SendOnWatchedPageChangeMessage(tab, matched_selectors);
+  EXPECT_EQ(++expected_evaluation_requests, delegate()->evaluation_requests());
+
+  // Check that GetMatchingCssSelectors produces the same matched selectors as
+  // were sent by the OnWatchedPageChange message.
+  base::hash_set<std::string> matching_selectors;
+  tracker->GetMatchingCssSelectors(tab, &matching_selectors);
+  EXPECT_THAT(matching_selectors,
+              UnorderedElementsAreArray(matched_selectors));
+  EXPECT_EQ(expected_evaluation_requests, delegate()->evaluation_requests());
+
+  // Check that an in-page navigation has no effect on the matching selectors.
+  {
+    content::LoadCommittedDetails details;
+    details.is_in_page = true;
+    content::FrameNavigateParams params;
+    tracker->OnWebContentsNavigation(tab, details, params);
+    matching_selectors.clear();
+    tracker->GetMatchingCssSelectors(tab, &matching_selectors);
+    EXPECT_THAT(matching_selectors,
+                UnorderedElementsAreArray(matched_selectors));
+    EXPECT_EQ(expected_evaluation_requests, delegate()->evaluation_requests());
+  }
+
+  // Check that a non in-page navigation clears the matching selectors and
+  // requests condition evaluation.
+  {
+    content::LoadCommittedDetails details;
+    details.is_in_page = false;
+    content::FrameNavigateParams params;
+    tracker->OnWebContentsNavigation(tab, details, params);
+    matching_selectors.clear();
+    tracker->GetMatchingCssSelectors(tab, &matching_selectors);
+    EXPECT_TRUE(matching_selectors.empty());
+    EXPECT_EQ(++expected_evaluation_requests,
+              delegate()->evaluation_requests());
+  }
+}
+
+}  // namespace extensions

chrome/browser/extensions/tab_helper.cc

@@ -264,8 +264,6 @@ bool TabHelper::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ContentScriptsExecuting,
                         OnContentScriptsExecuting)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OnWatchedPageChange,
-                        OnWatchedPageChange)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -433,15 +431,6 @@ void TabHelper::OnContentScriptsExecuting(
       OnScriptsExecuted(web_contents(), executing_scripts_map, on_url));
 }
 
-void TabHelper::OnWatchedPageChange(
-    const std::vector<std::string>& css_selectors) {
-  if (ExtensionSystem::Get(profile_)->extension_service() &&
-      RulesRegistryService::Get(profile_)) {
-    RulesRegistryService::Get(profile_)->content_rules_registry()->Apply(
-        web_contents(), css_selectors);
-  }
-}
-
 void TabHelper::OnDetailedConsoleMessageAdded(
     const base::string16& message,
     const base::string16& source,

chrome/browser/extensions/tab_helper.h

@@ -7,7 +7,6 @@
 
 #include <set>
 #include <string>
-#include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ -171,7 +170,6 @@ class TabHelper : public content::WebContentsObserver,
   void OnContentScriptsExecuting(
       const ScriptExecutionObserver::ExecutingScriptsMap& extension_ids,
       const GURL& on_url);
-  void OnWatchedPageChange(const std::vector<std::string>& css_selectors);
   void OnDetailedConsoleMessageAdded(const base::string16& message,
                                      const base::string16& source,
                                      const StackTrace& stack_trace,

chrome/chrome_browser_extensions.gypi

@@ -213,6 +213,8 @@
       'browser/extensions/api/declarative_content/content_condition.h',
       'browser/extensions/api/declarative_content/content_constants.cc',
       'browser/extensions/api/declarative_content/content_constants.h',
+      'browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.cc',
+      'browser/extensions/api/declarative_content/declarative_content_css_condition_tracker.h',
       'browser/extensions/api/desktop_capture/desktop_capture_api.cc',
       'browser/extensions/api/desktop_capture/desktop_capture_api.h',
       'browser/extensions/api/desktop_capture/desktop_capture_base.cc',

chrome/chrome_tests_unit.gypi

@@ -656,6 +656,7 @@
       'browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc',
       'browser/extensions/api/declarative_content/content_action_unittest.cc',
       'browser/extensions/api/declarative_content/content_condition_unittest.cc',
+      'browser/extensions/api/declarative_content/declarative_content_css_condition_tracker_unittest.cc',
       'browser/extensions/api/declarative_webrequest/webrequest_action_unittest.cc',
       'browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc',
       'browser/extensions/api/developer_private/developer_private_api_unittest.cc',

extensions/browser/api/declarative_content/content_rules_registry.h

@@ -36,12 +36,6 @@ class ContentRulesRegistry : public RulesRegistry {
                       cache_delegate,
                       rules_registry_id) {}
 
-  // Applies all content rules given an update (CSS match change or
-  // page navigation, for now) from the renderer.
-  virtual void Apply(
-      content::WebContents* contents,
-      const std::vector<std::string>& matching_css_selectors) = 0;
-
   // Applies all content rules given that a tab was just navigated.
   virtual void DidNavigateMainFrame(
       content::WebContents* tab,