Handle per-tab AUTOMATIC_DOWNLOADS setting in DownloadRequestLimiter.

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 <stddef.h>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/chrome_content_settings_utils.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
+#include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
 #include "chrome/browser/plugins/plugin_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
 #include "chrome/browser/ui/collected_cookies_infobar_delegate.h"
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model_delegate.h"
@@ skipping 106 matching lines @@
   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_TITLE},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_TITLE},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT,
         IDS_BLOCKED_DISPLAYING_INSECURE_CONTENT},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER,
         IDS_BLOCKED_PPAPI_BROKER_TITLE},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_TITLE},
   };
   // Fields as for kBlockedTitleIDs, above.
   static const ContentSettingsTypeIdEntry kAccessedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_ACCESSED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_TITLE},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_TITLE},
   };
   const ContentSettingsTypeIdEntry* title_ids = kBlockedTitleIDs;
   size_t num_title_ids = arraysize(kBlockedTitleIDs);
   if (content_settings && content_settings->IsContentAllowed(content_type()) &&
       !content_settings->IsContentBlocked(content_type())) {
     title_ids = kAccessedTitleIDs;
     num_title_ids = arraysize(kAccessedTitleIDs);
   }
   int title_id = GetIdForContentType(title_ids, num_title_ids, content_type());
   if (title_id)
     set_title(l10n_util::GetStringUTF16(title_id));
 }
 
 void ContentSettingSimpleBubbleModel::SetManageText() {
   static const ContentSettingsTypeIdEntry kLinkIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_LINK},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_LINK},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_LINK},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LINK},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_LINK},
     {CONTENT_SETTINGS_TYPE_GEOLOCATION, IDS_GEOLOCATION_BUBBLE_MANAGE_LINK},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT, IDS_LEARN_MORE},
     {CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, IDS_HANDLERS_BUBBLE_MANAGE_LINK},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_PPAPI_BROKER_BUBBLE_MANAGE_LINK},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOADS_LINK},
     {CONTENT_SETTINGS_TYPE_MIDI_SYSEX, IDS_MIDI_SYSEX_BUBBLE_MANAGE_LINK},
   };
   set_manage_text(l10n_util::GetStringUTF8(
       GetIdForContentType(kLinkIDs, arraysize(kLinkIDs), content_type())));
 }
 
 void ContentSettingSimpleBubbleModel::OnManageLinkClicked() {
   if (delegate())
     delegate()->ShowContentSettingsPage(content_type());
 
@@ skipping 92 matching lines @@
   RadioGroup radio_group;
   radio_group.url = url;
 
   static const ContentSettingsTypeIdEntry kBlockedAllowIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_UNBLOCK_ALL},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_BLOCKED_PPAPI_BROKER_UNBLOCK},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_UNBLOCK},
   };
   // Fields as for kBlockedAllowIDs, above.
   static const ContentSettingsTypeIdEntry kAllowedAllowIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_ALLOWED_COOKIES_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_NO_ACTION},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_NO_ACTION},
   };
 
   std::string radio_allow_label;
   if (allowed) {
     int resource_id = GetIdForContentType(kAllowedAllowIDs,
                                           arraysize(kAllowedAllowIDs),
                                           content_type());
     radio_allow_label = l10n_util::GetStringUTF8(resource_id);
   } else {
     radio_allow_label = l10n_util::GetStringFUTF8(
         GetIdForContentType(kBlockedAllowIDs, arraysize(kBlockedAllowIDs),
                             content_type()),
         display_host);
   }
 
   static const ContentSettingsTypeIdEntry kBlockedBlockIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_BLOCKED_PPAPI_BROKER_NO_ACTION},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_NO_ACTION},
   };
   static const ContentSettingsTypeIdEntry kAllowedBlockIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_ALLOWED_COOKIES_BLOCK},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_BLOCK},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_BLOCK},
   };
 
   std::string radio_block_label;
   if (allowed) {
     int resource_id = GetIdForContentType(kAllowedBlockIDs,
                                           arraysize(kAllowedBlockIDs),
                                           content_type());
     radio_block_label = l10n_util::GetStringFUTF8(resource_id, display_host);
   } else {
     radio_block_label = l10n_util::GetStringUTF8(
@@ skipping 1000 matching lines @@
   for (const std::pair<GURL, ContentSetting>& map_entry : state_map) {
     PermissionUtil::ScopedRevocationReporter(
         profile(), map_entry.first, embedder_url,
         CONTENT_SETTINGS_TYPE_MIDI_SYSEX, PermissionSourceUI::PAGE_ACTION);
     map->SetContentSettingDefaultScope(map_entry.first, embedder_url,
                                        CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                        std::string(), CONTENT_SETTING_DEFAULT);
   }
 }
 
+// ContentSettingDownloadsBubbleModel ------------------------------------------
+
+ContentSettingDownloadsBubbleModel::ContentSettingDownloadsBubbleModel(
+    Delegate* delegate,
+    WebContents* web_contents,
+    Profile* profile)
+    : ContentSettingBubbleModel(delegate, web_contents, profile) {
+  SetTitle();
+  SetManageText();
+  SetRadioGroup();
+}
+
+ContentSettingDownloadsBubbleModel::~ContentSettingDownloadsBubbleModel() {
+  if (profile() &&
+      selected_item_ != bubble_content().radio_group.default_item) {
+    ContentSetting setting = selected_item_ == kAllowButtonIndex
+                                 ? CONTENT_SETTING_ALLOW
+                                 : CONTENT_SETTING_BLOCK;
+    auto* map = HostContentSettingsMapFactory::GetForProfile(profile());
+    map->SetNarrowestContentSetting(
+        bubble_content().radio_group.url, bubble_content().radio_group.url,
+        CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, setting);
+  }
+}
+
+ContentSettingDownloadsBubbleModel*
+ContentSettingDownloadsBubbleModel::AsDownloadsBubbleModel() {
+  return this;
+}
+
+// Initialize the radio group by setting the appropriate labels for the
+// content type and setting the default value based on the content setting.
+void ContentSettingDownloadsBubbleModel::SetRadioGroup() {
+  GURL url = web_contents()->GetURL();
+  base::string16 display_host = url_formatter::FormatUrlForSecurityDisplay(url);
+  if (display_host.empty())
+    display_host = base::ASCIIToUTF16(url.spec());
+
+  RadioGroup radio_group;
+  radio_group.url = url;
+  switch (g_browser_process->download_request_limiter()->GetDownloadStatus(
+      web_contents())) {
+    case DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS:
+      radio_group.radio_items.push_back(
+          l10n_util::GetStringUTF8(IDS_ALLOWED_DOWNLOAD_NO_ACTION));
+      radio_group.radio_items.push_back(
+          l10n_util::GetStringFUTF8(IDS_ALLOWED_DOWNLOAD_BLOCK, display_host));
+      radio_group.default_item = kAllowButtonIndex;
+      break;
+    case DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED:
+      radio_group.radio_items.push_back(l10n_util::GetStringFUTF8(
+          IDS_BLOCKED_DOWNLOAD_UNBLOCK, display_host));
+      radio_group.radio_items.push_back(
+          l10n_util::GetStringUTF8(IDS_BLOCKED_DOWNLOAD_NO_ACTION));
+      radio_group.default_item = 1;
+      break;
+    default:
+      NOTREACHED();
+      return;
+  }
+  set_radio_group(radio_group);
+  selected_item_ = radio_group.default_item;
+
+  SettingInfo info;
+  HostContentSettingsMap* map =
+      HostContentSettingsMapFactory::GetForProfile(profile());
+  map->GetWebsiteSetting(url, url, CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
+                         std::string(), &info);
+
+  // Prevent creation of content settings for illegal urls like about:blank
+  bool is_valid = map->CanSetNarrowestContentSetting(
+      url, url, CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS);
+
+  set_radio_group_enabled(is_valid && info.source == SETTING_SOURCE_USER);
+}
+
+void ContentSettingDownloadsBubbleModel::OnRadioClicked(int radio_index) {
+  selected_item_ = radio_index;
+}
+
+void ContentSettingDownloadsBubbleModel::SetTitle() {
+  if (!web_contents())
+    return;
+  switch (g_browser_process->download_request_limiter()->GetDownloadStatus(
+      web_contents())) {
+    case DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS:
+      set_title(l10n_util::GetStringUTF16(IDS_ALLOWED_DOWNLOAD_TITLE));
+      return;
+    case DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED:
+      set_title(l10n_util::GetStringUTF16(IDS_BLOCKED_DOWNLOAD_TITLE));
+      return;
+    default:
+      // No title otherwise.
+      return;
+  }
+}
+
+void ContentSettingDownloadsBubbleModel::SetManageText() {
+  set_manage_text(l10n_util::GetStringUTF8(IDS_BLOCKED_DOWNLOADS_LINK));
+}
+
+void ContentSettingDownloadsBubbleModel::OnManageLinkClicked() {
+  if (delegate())
+    delegate()->ShowContentSettingsPage(
+        CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS);
+}
+
 // ContentSettingBubbleModel ---------------------------------------------------
 
 // static
 ContentSettingBubbleModel*
     ContentSettingBubbleModel::CreateContentSettingBubbleModel(
         Delegate* delegate,
         WebContents* web_contents,
         Profile* profile,
         ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
@@ skipping 19 matching lines @@
         ProtocolHandlerRegistryFactory::GetForBrowserContext(profile);
     return new ContentSettingRPHBubbleModel(delegate, web_contents, profile,
                                             registry);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
     return new ContentSettingMidiSysExBubbleModel(delegate, web_contents,
                                                   profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_IMAGES ||
       content_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
-      content_type == CONTENT_SETTINGS_TYPE_PPAPI_BROKER ||
-      content_type == CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS) {
+      content_type == CONTENT_SETTINGS_TYPE_PPAPI_BROKER) {
     return new ContentSettingSingleRadioGroup(delegate, web_contents, profile,
                                               content_type);
   }
+  if (content_type == CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS) {
+    return new ContentSettingDownloadsBubbleModel(delegate, web_contents,
+                                                  profile);
+  }
   NOTREACHED() << "No bubble for the content type " << content_type << ".";
   return nullptr;
 }
 
 ContentSettingBubbleModel::ContentSettingBubbleModel(Delegate* delegate,
                                                      WebContents* web_contents,
                                                      Profile* profile)
     : web_contents_(web_contents),
       profile_(profile),
       delegate_(delegate),
@@ skipping 56 matching lines @@
 ContentSettingMediaStreamBubbleModel*
     ContentSettingBubbleModel::AsMediaStreamBubbleModel() {
   // In general, bubble models might not inherit from the media bubble model.
   return nullptr;
 }
 
 ContentSettingSubresourceFilterBubbleModel*
 ContentSettingBubbleModel::AsSubresourceFilterBubbleModel() {
   return nullptr;
 }
+
+ContentSettingDownloadsBubbleModel*
+ContentSettingBubbleModel::AsDownloadsBubbleModel() {
+  return nullptr;
+}