Updated Plugin bubble model to add "learn more" link and to appear with a sliding yellow thing

chrome/browser/ui/content_settings/content_setting_bubble_model.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/ui/content_settings/content_setting_bubble_model.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 32 matching lines @@
 using base::UserMetricsAction;
 using content::WebContents;
 using content_settings::SettingInfo;
 using content_settings::SettingSource;
 using content_settings::SETTING_SOURCE_USER;
 using content_settings::SETTING_SOURCE_NONE;
 
 namespace {
 
 const int kAllowButtonIndex = 0;
+const int kAllowOnceButtonIndex = 1;
 
 struct ContentSettingsTypeIdEntry {
   ContentSettingsType type;
   int id;
 };
 
 int GetIdForContentType(const ContentSettingsTypeIdEntry* entries,
                         size_t num_entries,
                         ContentSettingsType type) {
   for (size_t i = 0; i < num_entries; ++i) {
@@ skipping 25 matching lines @@
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingBubbleModel(web_contents, profile, content_type),
         delegate_(delegate) {
   // Notifications do not have a bubble.
   DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   SetTitle();
   SetManageLink();
+  SetLearnMoreLink();
 }
 
 void ContentSettingTitleAndLinkModel::SetTitle() {
   static const ContentSettingsTypeIdEntry kBlockedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_TITLE},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_TITLE},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_MESSAGE},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_TITLE},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT,
@@ skipping 41 matching lines @@
   };
   set_manage_link(l10n_util::GetStringUTF8(
       GetIdForContentType(kLinkIDs, arraysize(kLinkIDs), content_type())));
 }
 
 void ContentSettingTitleAndLinkModel::OnManageLinkClicked() {
   if (delegate_)
     delegate_->ShowContentSettingsPage(content_type());
 }
 
+void ContentSettingTitleAndLinkModel::SetLearnMoreLink() {
+  static const ContentSettingsTypeIdEntry kLearnMoreLinkIDs[] = {
+    {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_LEARN_MORE},
+  };
+  int learn_more_link_id =
+      GetIdForContentType(kLearnMoreLinkIDs, arraysize(kLearnMoreLinkIDs),
+                          content_type());
+  if (learn_more_link_id)
+    set_learn_more_link(l10n_util::GetStringUTF8(learn_more_link_id));
+}
+
+void ContentSettingTitleAndLinkModel::OnLearnMoreLinkClicked() {
+  if (delegate_)
+    delegate_->ShowLearnMorePage(content_type());
+}
+
 class ContentSettingTitleLinkAndCustomModel
     : public ContentSettingTitleAndLinkModel {
  public:
   ContentSettingTitleLinkAndCustomModel(Delegate* delegate,
                                         WebContents* web_contents,
                                         Profile* profile,
                                         ContentSettingsType content_type);
   virtual ~ContentSettingTitleLinkAndCustomModel() {}
 
  private:
   void SetCustomLink();
   virtual void OnCustomLinkClicked() OVERRIDE {}
 };
 
 ContentSettingTitleLinkAndCustomModel::ContentSettingTitleLinkAndCustomModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingTitleAndLinkModel(
           delegate, web_contents, profile, content_type) {
   SetCustomLink();
 }
 
 void ContentSettingTitleLinkAndCustomModel::SetCustomLink() {
   static const ContentSettingsTypeIdEntry kCustomIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_INFO},
-    {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LOAD_ALL},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT, IDS_ALLOW_INSECURE_CONTENT_BUTTON},
   };
   int custom_link_id =
       GetIdForContentType(kCustomIDs, arraysize(kCustomIDs), content_type());
   if (custom_link_id)
     set_custom_link(l10n_util::GetStringUTF8(custom_link_id));
 }
 
 class ContentSettingSingleRadioGroup
     : public ContentSettingTitleLinkAndCustomModel {
@@ skipping 24 matching lines @@
     ContentSettingsType content_type)
     : ContentSettingTitleLinkAndCustomModel(delegate, web_contents, profile,
                                             content_type),
       block_setting_(CONTENT_SETTING_BLOCK),
       selected_item_(0) {
   SetRadioGroup();
 }
 
 ContentSettingSingleRadioGroup::~ContentSettingSingleRadioGroup() {
   if (settings_changed()) {
-    ContentSetting setting =
-        selected_item_ == kAllowButtonIndex ?
-                          CONTENT_SETTING_ALLOW :
-                          block_setting_;
+    ContentSetting setting;
+    if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS) {
+      if (selected_item_ == kAllowButtonIndex)
+        setting = CONTENT_SETTING_ALLOW;
+      else if (selected_item_ == kAllowOnceButtonIndex)
+        setting = CONTENT_SETTING_DEFAULT;
+      else
+        setting = block_setting_;
+      TabSpecificContentSettings::FromWebContents(web_contents())->
+          set_plugin_bubble_setting(setting);
+    } else {
+      setting = selected_item_ == kAllowButtonIndex ?
+          CONTENT_SETTING_ALLOW : block_setting_;
+    }
     AddException(setting);
   }
 }
 
 bool ContentSettingSingleRadioGroup::settings_changed() const {
-  return selected_item_ != bubble_content().radio_group.default_item;
+    return selected_item_ != bubble_content().radio_group.default_item;
 }
 
 // Initialize the radio group by setting the appropriate labels for the
 // content type and setting the default value based on the content setting.
 void ContentSettingSingleRadioGroup::SetRadioGroup() {
   GURL url = web_contents()->GetURL();
   base::string16 display_host;
   net::AppendFormattedHost(
       url,
       profile()->GetPrefs()->GetString(prefs::kAcceptLanguages),
@@ skipping 67 matching lines @@
                                           content_type());
     radio_block_label = (content_type() == CONTENT_SETTINGS_TYPE_COOKIES) ?
         l10n_util::GetStringUTF8(resource_id) :
         l10n_util::GetStringFUTF8(resource_id, display_host);
   } else {
     radio_block_label = l10n_util::GetStringUTF8(
         GetIdForContentType(kBlockedBlockIDs, arraysize(kBlockedBlockIDs),
                             content_type()));
   }
 
+  static const ContentSettingsTypeIdEntry kBlockedAllowOnceIDs[] = {
+    {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LOAD_ALL},
+  };
+
+  std::string radio_allow_once_label;
+  radio_allow_once_label = l10n_util::GetStringUTF8(
+      GetIdForContentType(kBlockedAllowOnceIDs, arraysize(kBlockedAllowOnceIDs),
+                          content_type()));
+
   radio_group.radio_items.push_back(radio_allow_label);
+  if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS)
+    radio_group.radio_items.push_back(radio_allow_once_label);
   radio_group.radio_items.push_back(radio_block_label);
   ContentSetting setting;
   SettingSource setting_source = SETTING_SOURCE_NONE;
   bool setting_is_wildcard = false;
 
   if (content_type() == CONTENT_SETTINGS_TYPE_COOKIES) {
     CookieSettings* cookie_settings =
         CookieSettings::Factory::GetForProfile(profile()).get();
     setting = cookie_settings->GetCookieSetting(
         url, url, true, &setting_source);
   } else {
     SettingInfo info;
     HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
     scoped_ptr<base::Value> value(map->GetWebsiteSetting(
         url, url, content_type(), std::string(), &info));
-    setting = content_settings::ValueToContentSetting(value.get());
+    if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS)
+      setting = content_settings->plugin_bubble_setting();
+    else
+      setting = content_settings::ValueToContentSetting(value.get());
     setting_source = info.source;
     setting_is_wildcard =
         info.primary_pattern == ContentSettingsPattern::Wildcard() &&
         info.secondary_pattern == ContentSettingsPattern::Wildcard();
   }
 
   if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS &&
       setting == CONTENT_SETTING_ALLOW &&
       setting_is_wildcard) {
     // In the corner case of unrecognized plugins (which are now blocked by
     // default) we indicate the blocked state in the UI and allow the user to
     // whitelist.
-    radio_group.default_item = 1;
+    radio_group.default_item = 2;
+  } else if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS &&
+             setting == CONTENT_SETTING_DEFAULT) {
+    radio_group.default_item = kAllowOnceButtonIndex;
   } else if (setting == CONTENT_SETTING_ALLOW) {
     radio_group.default_item = kAllowButtonIndex;
     // |block_setting_| is already set to |CONTENT_SETTING_BLOCK|.
   } else {
-    radio_group.default_item = 1;
+    content_type() == CONTENT_SETTINGS_TYPE_PLUGINS ?
+        radio_group.default_item = 2 :
+        radio_group.default_item = 1;
     block_setting_ = setting;
   }
 
   set_setting_is_managed(setting_source != SETTING_SOURCE_USER);
   if (setting_source != SETTING_SOURCE_USER) {
     set_radio_group_enabled(false);
   } else {
     set_radio_group_enabled(true);
   }
   selected_item_ = radio_group.default_item;
@@ skipping 75 matching lines @@
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingSingleRadioGroup(
           delegate, web_contents, profile, content_type) {
   DCHECK_EQ(content_type, CONTENT_SETTINGS_TYPE_PLUGINS);
   // Disable the "Run all plugins this time" link if the setting is managed and
   // can't be controlled by the user or if the user already clicked on the link
   // and ran all plugins.
+  // TODO(radhikabhar) this might not be needed if we switch to the new UI
   set_custom_link_enabled(!setting_is_managed() &&
                           web_contents &&
                           TabSpecificContentSettings::FromWebContents(
                               web_contents)->load_plugins_link_enabled());
 }
 
 ContentSettingPluginBubbleModel::~ContentSettingPluginBubbleModel() {
   if (settings_changed()) {
     // If the user elected to allow all plugins then run plugins at this time.
-    if (selected_item() == kAllowButtonIndex)
-      OnCustomLinkClicked();
+    if (selected_item() == kAllowButtonIndex
+       || selected_item() == kAllowOnceButtonIndex)
+       OnCustomLinkClicked();
   }
 }
 
 void ContentSettingPluginBubbleModel::OnCustomLinkClicked() {
   content::RecordAction(UserMetricsAction("ClickToPlay_LoadAll_Bubble"));
   DCHECK(web_contents());
 #if defined(ENABLE_PLUGINS)
   // TODO(bauerb): We should send the identifiers of blocked plug-ins here.
   ChromePluginServiceFilter::GetInstance()->AuthorizeAllPlugins(
       web_contents(), true, std::string());
@@ skipping 827 matching lines @@
   if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
     DCHECK_EQ(web_contents_,
               content::Source<WebContents>(source).ptr());
     web_contents_ = NULL;
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
     DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
     profile_ = NULL;
   }
 }