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 98 matching lines @@
     case Action::INJECTION_REMOVED_AD:
       ret_bit |= kAdRemoved;
       break;
     case Action::INJECTION_REPLACED_AD:
       ret_bit |= kAdReplaced;
       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& cleaned_url,
+                                 content::WebContents* web_contents) {
   // Let's try to avoid histogramming useless URLs.
-  if (url.empty() || url == content::kAboutBlankURL ||
-      url == chrome::kChromeUINewTabURL)
+  if (cleaned_url.empty() || cleaned_url == content::kAboutBlankURL ||
+      cleaned_url == chrome::kChromeUINewTabURL)
     return;
 
   int statuses[MAX_STATUS - 1];
   std::memset(statuses, 0, sizeof(statuses));
 
-  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) {
+  // |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(cleaned_url);
+  const ExtensionMap& exts = site_lookup->second;
+  std::vector<std::string> ad_injectors;
+  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)
+      ad_injectors.push_back(ext_iter->first);
   }
+  if (active_script_controller)
+    active_script_controller->OnAdInjectionDetected(ad_injectors);
 
   std::string prefix = "ExtensionActivity.";
-  if (GURL(url).host() != "www.google.com") {
+  if (GURL(cleaned_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]);
     UMA_HISTOGRAM_COUNTS_100(prefix + GetHistogramName(DOM_METHOD),
                              statuses[DOM_METHOD - 1]);
     UMA_HISTOGRAM_COUNTS_100(prefix + GetHistogramName(DOCUMENT_WRITE),
                              statuses[DOCUMENT_WRITE - 1]);
@@ skipping 85 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) {
-  SiteMap::iterator old_site_lookup = url_status_.find(url);
+void UmaPolicy::CleanupClosedPage(const std::string& cleaned_url,
+                                  content::WebContents* web_contents) {
+  SiteMap::iterator old_site_lookup = url_status_.find(cleaned_url);
   if (old_site_lookup == url_status_.end())
     return;
   old_site_lookup->second[kNumberOfTabs]--;
   if (old_site_lookup->second[kNumberOfTabs] == 0) {
-    HistogramOnClose(url);
-    url_status_.erase(url);
+    HistogramOnClose(cleaned_url, web_contents);
+    url_status_.erase(cleaned_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) {
   if (gurl.spec().empty())
@@ skipping 52 matching lines @@
       return "AdReplaced";
     case NONE:
     case MAX_STATUS:
     default:
       NOTREACHED();
       return "";
   }
 }
 
 }  // namespace extensions