Introduce ActiveScriptController; track active extension scripts

chrome/browser/extensions/activity_log/uma_policy.cc

 // Copyright 2013 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/activity_log/uma_policy.h"
 
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/active_script_controller.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
 #include "chrome/browser/extensions/activity_log/ad_network_database.h"
+#include "chrome/browser/extensions/location_bar_controller.h"
+#include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/dom_action_types.h"
 
 namespace extensions {
@@ skipping 12 matching lines @@
 const int kCreatedIframe      = 1 << UmaPolicy::CREATED_IFRAME;
 const int kCreatedDiv         = 1 << UmaPolicy::CREATED_DIV;
 const int kCreatedLink        = 1 << UmaPolicy::CREATED_LINK;
 const int kCreatedInput       = 1 << UmaPolicy::CREATED_INPUT;
 const int kCreatedEmbed       = 1 << UmaPolicy::CREATED_EMBED;
 const int kCreatedObject      = 1 << UmaPolicy::CREATED_OBJECT;
 const int kAdInjected         = 1 << UmaPolicy::AD_INJECTED;
 const int kAdRemoved          = 1 << UmaPolicy::AD_REMOVED;
 const int kAdReplaced         = 1 << UmaPolicy::AD_REPLACED;
 
+// A mask of all the ad injection flags.
+const int kAnyAdActivity = kAdInjected | kAdRemoved | kAdReplaced;
+
 }  // namespace
 
 // Class constants, also used in testing. --------------------------------------
 
 const char UmaPolicy::kNumberOfTabs[]       = "num_tabs";
 const size_t UmaPolicy::kMaxTabsTracked     = 50;
 
 // Setup and shutdown. ---------------------------------------------------------
 
 UmaPolicy::UmaPolicy(Profile* profile)
@@ skipping 103 matching lines @@
       break;
     case Action::NO_AD_INJECTION:
       break;
     case Action::NUM_INJECTION_TYPES:
       NOTREACHED();
   };
 
   return ret_bit;
 }
 
-void UmaPolicy::HistogramOnClose(const std::string& url) {
+void UmaPolicy::HistogramOnClose(const std::string& url,
+                                 content::WebContents* web_contents) {
   // Let's try to avoid histogramming useless URLs.
   if (url.empty() || url == content::kAboutBlankURL ||
       url == chrome::kChromeUINewTabURL)
     return;
 
   int statuses[MAX_STATUS - 1];
   std::memset(statuses, 0, sizeof(statuses));
 
+  // |web_contents| can be NULL in unit tests.
+  TabHelper* tab_helper =
+      web_contents ? TabHelper::FromWebContents(web_contents) : NULL;
+  ActiveScriptController* active_script_controller =
+      tab_helper && tab_helper->location_bar_controller() ?
+          tab_helper->location_bar_controller()->active_script_controller() :
+          NULL;
   SiteMap::iterator site_lookup = url_status_.find(url);
-  ExtensionMap exts = site_lookup->second;
-  ExtensionMap::iterator ext_iter;
-  for (ext_iter = exts.begin(); ext_iter != exts.end(); ++ext_iter) {
+  const ExtensionMap& exts = site_lookup->second;
+  for (ExtensionMap::const_iterator ext_iter = exts.begin();
+       ext_iter != exts.end();
+       ++ext_iter) {
     if (ext_iter->first == kNumberOfTabs)
       continue;
     for (int i = NONE + 1; i < MAX_STATUS; ++i) {
       if (ext_iter->second & (1 << i))
         statuses[i-1]++;
     }
+
+    if ((ext_iter->second & kAnyAdActivity) &&
+        active_script_controller) {
+      bool injection_could_have_been_stopped =
+          active_script_controller->HasActionForExtensionId(ext_iter->first);

[not at google - send to devlin, 2014/05/08 20:47:09]

for the enabled_ problem I mentioned in the controller, maybe move the UMA
logging onto the ASC interface and implement in there? Like
OnAdActivity(extension). I don't like the idea of exposing enabled() outside the
class. Hiding HasActionForExtensionId would be nice.

[Devlin, 2014/05/08 23:01:00]

Done.

+      UMA_HISTOGRAM_BOOLEAN(
+          "ExtensionActivity.AdInjectionCouldHaveBeenStopped",
+          injection_could_have_been_stopped);
+    }
   }
 
   std::string prefix = "ExtensionActivity.";
   if (GURL(url).host() != "www.google.com") {
     UMA_HISTOGRAM_COUNTS_100(prefix + GetHistogramName(CONTENT_SCRIPT),
                              statuses[CONTENT_SCRIPT - 1]);
     UMA_HISTOGRAM_COUNTS_100(prefix + GetHistogramName(READ_DOM),
                              statuses[READ_DOM - 1]);
     UMA_HISTOGRAM_COUNTS_100(prefix + GetHistogramName(MODIFIED_DOM),
                              statuses[MODIFIED_DOM - 1]);
@@ skipping 89 matching lines @@
   int32 tab_id = SessionID::IdForTab(contents);
 
   std::map<int32, std::string>::iterator tab_it = tab_list_.find(tab_id);
 
   // Ignore tabs that haven't changed status.
   if (tab_it != tab_list_.end() && tab_it->second == url)
     return;
 
   // Is this an existing tab whose URL has changed.
   if (tab_it != tab_list_.end()) {
-    CleanupClosedPage(tab_it->second);
+    CleanupClosedPage(tab_it->second, contents);
     tab_list_.erase(tab_id);
   }
 
   // Check that tab_list_ isn't over the kMaxTabsTracked budget.
   if (tab_list_.size() >= kMaxTabsTracked)
     return;
 
   // Set up the new entries.
   tab_list_[tab_id] = url;
   SetupOpenedPage(url);
 }
 
 // Use the value from SessionID::IdForTab, *not* |index|. |index| will be
 // duplicated across tabs in a session, whereas IdForTab uniquely identifies
 // each tab.
 void UmaPolicy::TabClosingAt(TabStripModel* tab_strip_model,
                              content::WebContents* contents,
                              int index) {
   if (!contents)
     return;
   std::string url = CleanURL(contents->GetLastCommittedURL());
   int32 tab_id = SessionID::IdForTab(contents);
   std::map<int, std::string>::iterator tab_it = tab_list_.find(tab_id);
   if (tab_it != tab_list_.end())
     tab_list_.erase(tab_id);
 
-  CleanupClosedPage(url);
+  CleanupClosedPage(url, contents);
 }
 
 void UmaPolicy::SetupOpenedPage(const std::string& url) {
   url_status_[url][kNumberOfTabs]++;
 }
 
-void UmaPolicy::CleanupClosedPage(const std::string& url) {
+void UmaPolicy::CleanupClosedPage(const std::string& url,
+                                  content::WebContents* web_contents) {
   SiteMap::iterator old_site_lookup = url_status_.find(url);
   if (old_site_lookup == url_status_.end())
     return;
   old_site_lookup->second[kNumberOfTabs]--;
   if (old_site_lookup->second[kNumberOfTabs] == 0) {
-    HistogramOnClose(url);
+    HistogramOnClose(url, web_contents);
     url_status_.erase(url);
   }
 }
 
 // Helpers. --------------------------------------------------------------------
 
 // We don't want to treat # ref navigations as if they were new pageloads.
 // So we get rid of the ref if it has it.
 // We convert to a string in the hopes that this is faster than Replacements.
 std::string UmaPolicy::CleanURL(const GURL& gurl) {
@@ skipping 53 matching lines @@
       return "AdReplaced";
     case NONE:
     case MAX_STATUS:
     default:
       NOTREACHED();
       return "";
   }
 }
 
 }  // namespace extensions