Add the names of plugins to the blocked plugin bubble.

chrome/browser/content_settings/tab_specific_content_settings.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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 219 matching lines @@
                                                     int render_frame_id,
                                                     const GURL& url,
                                                     bool blocked_by_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TabSpecificContentSettings* settings = GetForFrame(
       render_process_id, render_frame_id);
   if (settings)
     settings->OnFileSystemAccessed(url, blocked_by_policy);
 }
 
+const base::string16 TabSpecificContentSettings::blocked_plugin_names() const {
+  const base::string16 kComma = base::string16(base::ASCIIToUTF16(", "));

[Lei Zhang, 2014/12/05 22:18:05]

You don't need to call base::string16().

[Will Harris, 2014/12/08 00:21:11]

Done.

+
+  base::string16 names;
+  base::hash_set<base::string16>::const_iterator it =

[Lei Zhang, 2014/12/05 22:18:05]

You can probably just make this a C++11 Range-Based For Loops.

[Will Harris, 2014/12/08 00:21:11]

left using iterator as it's the fastest way to check I'm on the final element
and not add the comma.

+      blocked_plugin_names_.begin();
+  while (it != blocked_plugin_names_.end()) {
+    names.append(*it);
+    it++;

[Lei Zhang, 2014/12/05 22:18:05]

++it;

[Will Harris, 2014/12/08 00:21:11]

Done.

+    if (it != blocked_plugin_names_.end())
+      names.append(kComma);
+    else
+      break;
+  }
+
+  return names;
+}
+
 bool TabSpecificContentSettings::IsContentBlocked(
     ContentSettingsType content_type) const {
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by ContentSettingGeolocationImageModel";
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
       << "Notifications settings handled by "
       << "ContentSettingsNotificationsImageModel";
 
   if (content_type == CONTENT_SETTINGS_TYPE_IMAGES ||
       content_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
@@ skipping 34 matching lines @@
       content_type != CONTENT_SETTINGS_TYPE_PPAPI_BROKER &&
       content_type != CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS &&
       content_type != CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
     return false;
   }
 
   return content_allowed_[content_type];
 }
 
 void TabSpecificContentSettings::OnContentBlocked(ContentSettingsType type) {
+  OnContentBlockedWithDetail(type, base::string16());
+}
+
+void TabSpecificContentSettings::OnContentBlockedWithDetail(
+    ContentSettingsType type,
+    const base::string16& details) {
   DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by OnGeolocationPermissionSet";
   DCHECK(type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC &&
          type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)
       << "Media stream settings handled by OnMediaStreamPermissionSet";
   if (type < 0 || type >= CONTENT_SETTINGS_NUM_TYPES)
     return;
 
   // TODO(robwu): Should this be restricted to cookies only?
   // In the past, content_allowed_ was set to false, but this logic was inverted
   // in https://codereview.chromium.org/13375004 to fix an issue with the cookie
   // permission UI. This unconditional assignment seems incorrect, because the
   // flag will now always be true after calling either OnContentBlocked or
   // OnContentAllowed. Consequently IsContentAllowed will always return true
   // for every supported setting that is not handled elsewhere.
   content_allowed_[type] = true;
 
 #if defined(OS_ANDROID)
   if (type == CONTENT_SETTINGS_TYPE_POPUPS) {
     // For Android we do not have a persistent button that will always be
     // visible for blocked popups.  Instead we have info bars which could be
     // dismissed.  Have to clear the blocked state so we properly notify the
     // relevant pieces again.
     content_blocked_[type] = false;
     content_blockage_indicated_to_user_[type] = false;
   }
 #endif
 
+  if (type == CONTENT_SETTINGS_TYPE_PLUGINS) {
+    blocked_plugin_names_.insert(details);
+  }
+
   if (!content_blocked_[type]) {
     content_blocked_[type] = true;
     // TODO: it would be nice to have a way of mocking this in tests.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
         content::Source<WebContents>(web_contents()),
         content::NotificationService::NoDetails());
 
     if (type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT) {
       content_settings::RecordMixedScriptAction(
@@ skipping 359 matching lines @@
   // page.
   render_frame_host->Send(new ChromeViewMsg_SetAsInterstitial(
       render_frame_host->GetRoutingID()));
 }
 
 bool TabSpecificContentSettings::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(TabSpecificContentSettings, message)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ContentBlocked, OnContentBlocked)

[Lei Zhang, 2014/12/05 22:18:05]

Is OnContentBlocked() still used?

[Will Harris, 2014/12/08 00:21:11]

used by the tests

[Lei Zhang, 2014/12/08 20:08:19]

If it's the case that only tests call it, it's probably time to change the tests
to use OnContentBlockedWithDetail() and delete OnContentBlocked().

[Will Harris, 2014/12/08 21:11:46]

Actually, changing the default function signature of OnContentBlocked() ends up
making almost all calls to it pass extra empty string parameter, so the CL turns
out to be more complex, so I'll leave OnContentBlocked() as a convenience
method.

+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ContentBlocked,
+                        OnContentBlockedWithDetail)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void TabSpecificContentSettings::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (!details.is_in_page) {
     // Clear "blocked" flags.
     ClearBlockedContentSettingsExceptForCookies();
+    blocked_plugin_names_.clear();
     GeolocationDidNavigate(details);
     MidiDidNavigate(details);
   }
 }
 
 void TabSpecificContentSettings::DidStartProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc) {
@@ skipping 45 matching lines @@
 
 void TabSpecificContentSettings::GeolocationDidNavigate(
       const content::LoadCommittedDetails& details) {
   geolocation_usages_state_.DidNavigate(details);
 }
 
 void TabSpecificContentSettings::MidiDidNavigate(
     const content::LoadCommittedDetails& details) {
   midi_usages_state_.DidNavigate(details);
 }