Add UMA metrics for blocked plugins.

chrome/renderer/content_settings_observer.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/renderer/content_settings_observer.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/database_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 66 matching lines @@
     ContentSettingsType type) {
   if (type == CONTENT_SETTINGS_TYPE_PLUGINS &&
       plugins_temporarily_allowed_) {
     return CONTENT_SETTING_ALLOW;
   }
   return current_content_settings_.settings[type];
 }
 
 void ContentSettingsObserver::DidBlockContentType(
     ContentSettingsType settings_type,
-    const std::string& resource_identifier) {
-  // Always send a message when |resource_identifier| is not empty, to tell the
-  // browser which resource was blocked (otherwise the browser will only show
-  // the first resource to be blocked, and none that are blocked at a later
-  // time).
-  if (!content_blocked_[settings_type] || !resource_identifier.empty()) {
-    content_blocked_[settings_type] = true;
-    Send(new ViewHostMsg_ContentBlocked(routing_id(), settings_type,
-                                        resource_identifier));
-  }
+    const std::string& resource_identifier,
+    ContentSetting setting) {
+   content_blocked_[settings_type] = true;
+   Send(new ViewHostMsg_ContentBlocked(routing_id(), settings_type,
+                                       resource_identifier, setting));
 }
 
 bool ContentSettingsObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     // Don't swallow LoadBlockedPlugins messages, as they're sent to every
     // blocked plugin.
     IPC_MESSAGE_HANDLER_GENERIC(ViewMsg_LoadBlockedPlugins,
                                 OnLoadBlockedPlugins(); handled = false)
     IPC_MESSAGE_HANDLER(ViewMsg_SetContentSettingsForLoadingURL,
@@ skipping 90 matching lines @@
 bool ContentSettingsObserver::AllowImages(WebFrame* frame,
                                           bool enabled_per_settings) {
   if (enabled_per_settings &&
       AllowContentType(CONTENT_SETTINGS_TYPE_IMAGES)) {
     return true;
   }
 
   if (IsWhitelistedForContentSettings(frame))
     return true;
 
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES, std::string());
+  DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES, std::string(),
+                      CONTENT_SETTING_BLOCK);
   return false;  // Other protocols fall through here.
 }
 
 bool ContentSettingsObserver::AllowIndexedDB(WebFrame* frame,
                                              const WebString& name,
                                              const WebSecurityOrigin& origin) {
   if (frame->document().securityOrigin().isEmpty() ||
       frame->top()->document().securityOrigin().isEmpty())
     return false; // Uninitialized document.
 
@@ skipping 39 matching lines @@
   Send(new ViewHostMsg_AllowDOMStorage(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()),
       local ? DOM_STORAGE_LOCAL : DOM_STORAGE_SESSION,
       &result));
   cached_storage_permissions_[key] = result;
   return result;
 }
 
 void ContentSettingsObserver::DidNotAllowPlugins(WebFrame* frame) {
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
+  DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, std::string(),
+                      CONTENT_SETTING_BLOCK);
 }
 
 void ContentSettingsObserver::DidNotAllowScript(WebFrame* frame) {
-  DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string());
+  DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string(),
+                      CONTENT_SETTING_BLOCK);
 }
 
 void ContentSettingsObserver::OnSetContentSettingsForLoadingURL(
     const GURL& url,
     const ContentSettings& content_settings) {
   host_content_settings_[url] = content_settings;
 }
 
 void ContentSettingsObserver::OnLoadBlockedPlugins() {
   plugins_temporarily_allowed_ = true;
 }
 
 bool ContentSettingsObserver::AllowContentType(
     ContentSettingsType settings_type) {
   // CONTENT_SETTING_ASK is only valid for cookies.
   return current_content_settings_.settings[settings_type] !=
       CONTENT_SETTING_BLOCK;
 }
 
 void ContentSettingsObserver::ClearBlockedContentSettings() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i)
     content_blocked_[i] = false;
   cached_storage_permissions_.clear();
 }