Add UMA metrics for blocked plugins.

chrome/browser/content_settings/tab_specific_content_settings.cc

 // Copyright (c) 2011 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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/lazy_instance.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data_local_storage_helper.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/cookies_tree_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
+#include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 #include "content/common/view_messages.h"
 #include "net/base/cookie_monster.h"
 #include "webkit/fileapi/file_system_types.h"
 
 namespace {
 typedef std::list<TabSpecificContentSettings*> TabSpecificList;
 static base::LazyInstance<TabSpecificList> g_tab_specific(
     base::LINKER_INITIALIZED);
 }
@@ skipping 161 matching lines @@
 void TabSpecificContentSettings::AddBlockedResource(
     ContentSettingsType content_type,
     const std::string& resource_identifier) {
   if (!blocked_resources_[content_type].get())
     blocked_resources_[content_type].reset(new std::set<std::string>());
   blocked_resources_[content_type]->insert(resource_identifier);
 }
 
 void TabSpecificContentSettings::OnContentBlocked(
     ContentSettingsType type,
-    const std::string& resource_identifier) {
+    const std::string& resource_identifier,
+    ContentSetting setting) {
   DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by OnGeolocationPermissionSet";
+  if (type == CONTENT_SETTINGS_TYPE_PLUGINS) {
+    if (setting == CONTENT_SETTING_BLOCK)
+      UserMetrics::RecordAction(UserMetricsAction("Plugin.Blocked"));
+    else if (setting == CONTENT_SETTING_ASK)
+      UserMetrics::RecordAction(UserMetricsAction("Plugin.ClickToPlay"));
+    else
+      NOTREACHED();
+  }
   content_accessed_[type] = true;
   if (!resource_identifier.empty())
     AddBlockedResource(type, resource_identifier);
   if (!content_blocked_[type]) {
     content_blocked_[type] = true;
     // TODO: it would be nice to have a way of mocking this in tests.
     NotificationService::current()->Notify(
         chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
         Source<TabContents>(tab_contents()),
         NotificationService::NoDetails());
@@ skipping 26 matching lines @@
     container.cookies()->SetCookieWithDetails(url,
                                               cookie->Name(),
                                               cookie->Value(),
                                               cookie->Domain(),
                                               cookie->Path(),
                                               cookie->ExpiryDate(),
                                               cookie->IsSecure(),
                                               cookie->IsHttpOnly());
   }
   if (blocked_by_policy)
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   else
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
 }
 
 void TabSpecificContentSettings::OnCookieChanged(
     const GURL& url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.cookies()->SetCookieWithOptions(
         url, cookie_line, options);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   } else {
     allowed_local_shared_objects_.cookies()->SetCookieWithOptions(
         url, cookie_line, options);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnIndexedDBAccessed(
     const GURL& url,
     const string16& description,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   } else {
     allowed_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnLocalStorageAccessed(
     const GURL& url,
     DOMStorageType storage_type,
     bool blocked_by_policy) {
   LocalSharedObjectsContainer& container = blocked_by_policy ?
       blocked_local_shared_objects_ : allowed_local_shared_objects_;
   CannedBrowsingDataLocalStorageHelper* helper =
       storage_type == DOM_STORAGE_LOCAL ?
           container.local_storages() : container.session_storages();
   helper->AddLocalStorage(url);
 
   if (blocked_by_policy)
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   else
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
 }
 
 void TabSpecificContentSettings::OnWebDatabaseAccessed(
     const GURL& url,
     const string16& name,
     const string16& display_name,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.databases()->AddDatabase(
         url, UTF16ToUTF8(name), UTF16ToUTF8(display_name));
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   } else {
     allowed_local_shared_objects_.databases()->AddDatabase(
         url, UTF16ToUTF8(name), UTF16ToUTF8(display_name));
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnAppCacheAccessed(
     const GURL& manifest_url, bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   } else {
     allowed_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnFileSystemAccessed(
     const GURL& url,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.file_systems()->AddFileSystem(url,
         fileapi::kFileSystemTypeTemporary, 0);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
+                     CONTENT_SETTING_BLOCK);
   } else {
     allowed_local_shared_objects_.file_systems()->AddFileSystem(url,
         fileapi::kFileSystemTypeTemporary, 0);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 void TabSpecificContentSettings::OnGeolocationPermissionSet(
     const GURL& requesting_origin,
     bool allowed) {
   geolocation_settings_state_.OnGeolocationPermissionSet(requesting_origin,
@@ skipping 168 matching lines @@
   return new CookiesTreeModel(cookies_,
                               databases_->Clone(),
                               local_storages_->Clone(),
                               session_storages_->Clone(),
                               appcaches_->Clone(),
                               indexed_dbs_->Clone(),
                               file_systems_->Clone(),
                               NULL,
                               true);
 }