Reland "Encapsulate CSS selector declarative content condition tracking"

chrome/browser/extensions/tab_helper.cc

 // Copyright (c) 2012 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/tab_helper.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 54 matching lines @@
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::RenderViewHost;
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::TabHelper);
 
 namespace extensions {
 
+// Encapsulates the logic to decide which ContentRulesRegistries need to be
+// invoked, depending on whether this WebContents is associated with an Original
+// or OffTheRecord profile. In the latter case, we need to invoke on both the
+// Original and OffTheRecord ContentRulesRegistries since the Original registry
+// handles spanning-mode incognito extensions.
+template <class Func>
+void TabHelper::InvokeForContentRulesRegistries(const Func& func) {

[not at google - send to devlin, 2015/06/09 20:38:11]

Usually methods are defined in the .cc file in the order they were declared in
the header file. Do you need to do it this way for the compiler or something?

You could fix this by putting this in an anonymous namespace, then currying
|profile_| into this function, like:

template <typename Func>
void InvokeForContentRulesRegistries(Profile* profile, const Func& func) {...}

?

[Mike Wittman, 2015/06/09 22:05:56]

I could swear that the template function had to be defined before being
instantiated (in the constructor below), but in trying to move it afterwards
apparently this is not the case. Perhaps instantiation requirements have been
relaxed in C++11, or maybe I'm just misremembering
This is what I had originally, but it makes the callsites less readable due to
the extra line breaks.

+  RulesRegistryService* rules_registry_service =
+      RulesRegistryService::Get(profile_);
+  if (rules_registry_service) {
+    func(rules_registry_service->content_rules_registry());
+    if (profile_->IsOffTheRecord()) {
+      // The original profile's content rules registry handles rules for
+      // spanning extensions in incognito profiles, so invoke it also.
+      RulesRegistryService* original_profile_rules_registry_service =
+          RulesRegistryService::Get(profile_->GetOriginalProfile());
+      DCHECK_NE(rules_registry_service,
+                original_profile_rules_registry_service);
+      if (original_profile_rules_registry_service)
+        func(original_profile_rules_registry_service->content_rules_registry());
+    }
+  }
+}
+
 TabHelper::TabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
+      profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       extension_app_(NULL),
-      extension_function_dispatcher_(
-          Profile::FromBrowserContext(web_contents->GetBrowserContext()),
-          this),
+      extension_function_dispatcher_(profile_, this),
       pending_web_app_action_(NONE),
       last_committed_nav_entry_unique_id_(0),
       update_shortcut_on_load_complete_(false),
       script_executor_(
           new ScriptExecutor(web_contents, &script_execution_observers_)),
       location_bar_controller_(new LocationBarController(web_contents)),
       active_script_controller_(new ActiveScriptController(web_contents)),
       webstore_inline_installer_factory_(new WebstoreInlineInstallerFactory()),
       image_loader_ptr_factory_(this),
       weak_ptr_factory_(this) {
   // The ActiveTabPermissionManager requires a session ID; ensure this
   // WebContents has one.
   SessionTabHelper::CreateForWebContents(web_contents);
   if (web_contents->GetRenderViewHost())
     SetTabId(web_contents->GetRenderViewHost());
   active_tab_permission_granter_.reset(new ActiveTabPermissionGranter(
       web_contents,
       SessionTabHelper::IdForTab(web_contents),
-      Profile::FromBrowserContext(web_contents->GetBrowserContext())));
-
-  // If more classes need to listen to global content script activity, then
-  // a separate routing class with an observer interface should be written.
-  profile_ = Profile::FromBrowserContext(web_contents->GetBrowserContext());
+      profile_));
 
   AddScriptExecutionObserver(ActivityLog::GetInstance(profile_));
 
+  InvokeForContentRulesRegistries([this](ContentRulesRegistry* registry) {
+    registry->MonitorWebContentsForRuleEvaluation(this->web_contents());
+  });
+
   registrar_.Add(this,
                  content::NOTIFICATION_LOAD_STOP,
                  content::Source<NavigationController>(
                      &web_contents->GetController()));
 }
 
 TabHelper::~TabHelper() {
   RemoveScriptExecutionObserver(ActivityLog::GetInstance(profile_));
 }
 
@@ skipping 80 matching lines @@
   pending_web_app_action_ = NONE;
 }
 
 void TabHelper::RenderViewCreated(RenderViewHost* render_view_host) {
   SetTabId(render_view_host);
 }
 
 void TabHelper::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
-  RulesRegistryService* rules_registry_service =
-      RulesRegistryService::Get(profile_);
-  if (rules_registry_service) {
-    rules_registry_service->content_rules_registry()->
-        DidNavigateMainFrame(web_contents(), details, params);
-    // The original profile's content rules registry handles rules for spanning
-    // extensions in incognito profiles, so let it know about the navigation
-    // also.
-    if (profile_->IsOffTheRecord()) {
-      RulesRegistryService* incognito_rules_registry_service =
-          RulesRegistryService::Get(profile_->GetOriginalProfile());
-      // The content and web request rules registries depend on separate
-      // instances for original/incognito profiles. See the comment on
-      // ChromeContentRulesRegistry.
-      DCHECK_NE(rules_registry_service, incognito_rules_registry_service);
-      if (incognito_rules_registry_service) {
-        incognito_rules_registry_service->content_rules_registry()->
-            DidNavigateMainFrame(web_contents(), details, params);
-      }
-    }
-  }
+  InvokeForContentRulesRegistries(
+      [this, &details, &params](ContentRulesRegistry* registry) {
+    registry->DidNavigateMainFrame(web_contents(), details, params);
+  });
 
   content::BrowserContext* context = web_contents()->GetBrowserContext();
   ExtensionRegistry* registry = ExtensionRegistry::Get(context);
   const ExtensionSet& enabled_extensions = registry->enabled_extensions();
 
   if (util::IsNewBookmarkAppsEnabled()) {
     Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
     if (browser && browser->is_app()) {
       const Extension* extension = registry->GetExtensionById(
           web_app::GetExtensionIdFromApplicationName(browser->app_name()),
@@ skipping 18 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(TabHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DidGetWebApplicationInfo,
                         OnDidGetWebApplicationInfo)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_InlineWebstoreInstall,
                         OnInlineWebstoreInstall)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GetAppInstallState,
                         OnGetAppInstallState);
     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;
 }
 
 bool TabHelper::OnMessageReceived(const IPC::Message& message,
                                   content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(TabHelper, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_DetailedConsoleMessageAdded,
@@ skipping 70 matching lines @@
   // Check that the listener is reasonable. We should never get anything other
   // than an install stage listener, a download listener, or both.
   if ((listeners_mask & ~(api::webstore::INSTALL_STAGE_LISTENER |
                           api::webstore::DOWNLOAD_PROGRESS_LISTENER)) != 0 ||
       requestor_url.is_empty()) {
     NOTREACHED();
     return;
   }
   // Inform the Webstore API that an inline install is happening, in case the
   // page requested status updates.
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
-
-  ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   if (registry->disabled_extensions().Contains(webstore_item_id) &&
-      (ExtensionPrefs::Get(profile)->GetDisableReasons(webstore_item_id) &
+      (ExtensionPrefs::Get(profile_)->GetDisableReasons(webstore_item_id) &
            Extension::DISABLE_PERMISSIONS_INCREASE) != 0) {
       // The extension was disabled due to permissions increase. Prompt for
       // re-enable.
       // TODO(devlin): We should also prompt for re-enable for other reasons,
       // like user-disabled.
       // For clarity, explicitly end any prior reenable process.
       extension_reenabler_.reset();
       extension_reenabler_ = ExtensionReenabler::PromptForReenable(
           registry->disabled_extensions().GetByID(webstore_item_id),
-          profile,
+          profile_,
           web_contents(),
           requestor_url,
           base::Bind(&TabHelper::OnReenableComplete,
                      weak_ptr_factory_.GetWeakPtr(),
                      install_id,
                      return_route_id));
   } else {
     // TODO(devlin): We should adddress the case of the extension already
     // being installed and enabled.
-    WebstoreAPI::Get(profile)->OnInlineInstallStart(
+    WebstoreAPI::Get(profile_)->OnInlineInstallStart(
         return_route_id, this, webstore_item_id, listeners_mask);
 
     WebstoreStandaloneInstaller::Callback callback =
         base::Bind(&TabHelper::OnInlineInstallComplete,
                    base::Unretained(this),
                    install_id,
                    return_route_id);
     scoped_refptr<WebstoreInlineInstaller> installer(
         webstore_inline_installer_factory_->CreateInstaller(
             web_contents(),
@@ skipping 31 matching lines @@
 
 void TabHelper::OnContentScriptsExecuting(
     const ScriptExecutionObserver::ExecutingScriptsMap& executing_scripts_map,
     const GURL& on_url) {
   FOR_EACH_OBSERVER(
       ScriptExecutionObserver,
       script_execution_observers_,
       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,
     const StackTrace& stack_trace,
     int32 severity_level) {
   if (IsSourceFromAnExtension(source)) {
     content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
     ErrorConsole::Get(profile_)->ReportError(
         scoped_ptr<ExtensionError>(new RuntimeError(
             extension_app_ ? extension_app_->id() : std::string(),
@@ skipping 18 matching lines @@
       extension_app_id);
 }
 
 void TabHelper::UpdateExtensionAppIcon(const Extension* extension) {
   extension_app_icon_.reset();
   // Ensure previously enqueued callbacks are ignored.
   image_loader_ptr_factory_.InvalidateWeakPtrs();
 
   // Enqueue OnImageLoaded callback.
   if (extension) {
-    Profile* profile =
-        Profile::FromBrowserContext(web_contents()->GetBrowserContext());
-    ImageLoader* loader = ImageLoader::Get(profile);
+    ImageLoader* loader = ImageLoader::Get(profile_);
     loader->LoadImageAsync(
         extension,
         IconsInfo::GetIconResource(extension,
                                    extension_misc::EXTENSION_ICON_SMALL,
                                    ExtensionIconSet::MATCH_BIGGER),
         gfx::Size(extension_misc::EXTENSION_ICON_SMALL,
                   extension_misc::EXTENSION_ICON_SMALL),
         base::Bind(&TabHelper::OnImageLoaded,
                    image_loader_ptr_factory_.GetWeakPtr()));
   }
@@ skipping 99 matching lines @@
   }
 }
 
 void TabHelper::SetTabId(RenderViewHost* render_view_host) {
   render_view_host->Send(
       new ExtensionMsg_SetTabId(render_view_host->GetRoutingID(),
                                 SessionTabHelper::IdForTab(web_contents())));
 }
 
 }  // namespace extensions