Handle per-tab AUTOMATIC_DOWNLOADS setting in DownloadRequestLimiter.

chrome/browser/ui/content_settings/content_setting_image_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_image_model.h"
 
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
+#include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/plugins/plugin_utils.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/vector_icons_public.h"
 
 using content::WebContents;
 
 // The image models hierarchy:
 //
 // ContentSettingImageModel                  - base class
 //   ContentSettingSimpleImageModel            - single content setting
 //     ContentSettingBlockedImageModel           - generic blocked setting
 //     ContentSettingGeolocationImageModel       - geolocation
 //     ContentSettingRPHImageModel               - protocol handlers
 //     ContentSettingMIDISysExImageModel         - midi sysex
+//     ContentSettingDownloadsImageModel         - automatic downloads
 //   ContentSettingMediaImageModel             - media
 //   ContentSettingSubresourceFilterImageModel - deceptive content
 
 class ContentSettingBlockedImageModel : public ContentSettingSimpleImageModel {
  public:
   explicit ContentSettingBlockedImageModel(ContentSettingsType content_type);
 
   void UpdateFromWebContents(WebContents* web_contents) override;
 
  private:
@@ skipping 40 matching lines @@
 class ContentSettingMIDISysExImageModel
     : public ContentSettingSimpleImageModel {
  public:
   ContentSettingMIDISysExImageModel();
 
   void UpdateFromWebContents(WebContents* web_contents) override;
  private:
   DISALLOW_COPY_AND_ASSIGN(ContentSettingMIDISysExImageModel);
 };
 
+class ContentSettingDownloadsImageModel
+    : public ContentSettingSimpleImageModel {
+ public:
+  ContentSettingDownloadsImageModel();
+
+  void UpdateFromWebContents(WebContents* web_contents) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingDownloadsImageModel);
+};
+
 namespace {
 
 struct ContentSettingsImageDetails {
   ContentSettingsType type;
   gfx::VectorIconId icon_id;
   int blocked_tooltip_id;
   int blocked_explanatory_text_id;
   int accessed_tooltip_id;
 };
 
 const ContentSettingsImageDetails kImageDetails[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, gfx::VectorIconId::COOKIE,
      IDS_BLOCKED_COOKIES_TITLE, 0, IDS_ACCESSED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_IMAGES, gfx::VectorIconId::IMAGE,
      IDS_BLOCKED_IMAGES_TITLE, 0, 0},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, gfx::VectorIconId::CODE,
      IDS_BLOCKED_JAVASCRIPT_TITLE, 0, 0},
     {CONTENT_SETTINGS_TYPE_PLUGINS, gfx::VectorIconId::EXTENSION,
      IDS_BLOCKED_PLUGINS_MESSAGE, IDS_BLOCKED_PLUGIN_EXPLANATORY_TEXT, 0},
     {CONTENT_SETTINGS_TYPE_POPUPS, gfx::VectorIconId::WEB,
      IDS_BLOCKED_POPUPS_TOOLTIP, IDS_BLOCKED_POPUPS_EXPLANATORY_TEXT, 0},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT, gfx::VectorIconId::MIXED_CONTENT,
      IDS_BLOCKED_DISPLAYING_INSECURE_CONTENT, 0, 0},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, gfx::VectorIconId::EXTENSION,
      IDS_BLOCKED_PPAPI_BROKER_TITLE, 0, IDS_ALLOWED_PPAPI_BROKER_TITLE},
-    {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
-     gfx::VectorIconId::FILE_DOWNLOAD, IDS_BLOCKED_DOWNLOAD_TITLE,
-     IDS_BLOCKED_DOWNLOADS_EXPLANATION, IDS_ALLOWED_DOWNLOAD_TITLE},
 };
 
 // The ordering of the models here influences the order in which icons are
 // shown in the omnibox.
 constexpr ContentSettingsType kContentTypeIconOrder[] = {
     CONTENT_SETTINGS_TYPE_COOKIES,
     CONTENT_SETTINGS_TYPE_IMAGES,
     CONTENT_SETTINGS_TYPE_JAVASCRIPT,
     CONTENT_SETTINGS_TYPE_PPAPI_BROKER,
     CONTENT_SETTINGS_TYPE_PLUGINS,
@@ skipping 65 matching lines @@
     ContentSettingsType content_settings_type) {
   if (content_settings_type == CONTENT_SETTINGS_TYPE_GEOLOCATION)
     return base::MakeUnique<ContentSettingGeolocationImageModel>();
 
   if (content_settings_type == CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS)
     return base::MakeUnique<ContentSettingRPHImageModel>();
 
   if (content_settings_type == CONTENT_SETTINGS_TYPE_MIDI_SYSEX)
     return base::MakeUnique<ContentSettingMIDISysExImageModel>();
 
+  if (content_settings_type == CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS)
+    return base::MakeUnique<ContentSettingDownloadsImageModel>();
+
   return base::MakeUnique<ContentSettingBlockedImageModel>(
       content_settings_type);
 }
 
 // Generic blocked content settings --------------------------------------------
 
 ContentSettingBlockedImageModel::ContentSettingBlockedImageModel(
     ContentSettingsType content_type)
     : ContentSettingSimpleImageModel(content_type) {
 }
@@ skipping 290 matching lines @@
   bool allowed =
       !!(state_flags & ContentSettingsUsagesState::TABSTATE_HAS_ANY_ALLOWED);
   set_icon_by_vector_id(gfx::VectorIconId::MIDI,
                         allowed ? gfx::VectorIconId::VECTOR_ICON_NONE
                                 : gfx::VectorIconId::BLOCKED_BADGE);
   set_tooltip(l10n_util::GetStringUTF16(allowed
                                             ? IDS_MIDI_SYSEX_ALLOWED_TOOLTIP
                                             : IDS_MIDI_SYSEX_BLOCKED_TOOLTIP));
 }
 
+// Automatic downloads ---------------------------------------------------------
+
+ContentSettingDownloadsImageModel::ContentSettingDownloadsImageModel()
+    : ContentSettingSimpleImageModel(
+          CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS) {}
+
+void ContentSettingDownloadsImageModel::UpdateFromWebContents(
+    WebContents* web_contents) {
+  set_visible(false);
+  if (!web_contents)
+    return;
+
+  DownloadRequestLimiter* download_request_limiter =
+      g_browser_process->download_request_limiter();
+
+  // DownloadRequestLimiter can be absent in unit_tests.
+  if (!download_request_limiter)
+    return;

[alshabalin, 2017/02/28 10:31:31]

Also added this check for the sake of unit_tests where there's no
DownloadRequestLimiter in TestingBrowserProcess.

+
+  switch (download_request_limiter->GetDownloadStatus(web_contents)) {
+    case DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS:
+      set_visible(true);
+      set_icon_by_vector_id(gfx::VectorIconId::FILE_DOWNLOAD,
+                            gfx::VectorIconId::VECTOR_ICON_NONE);
+      set_explanatory_string_id(0);
+      set_tooltip(l10n_util::GetStringUTF16(IDS_ALLOWED_DOWNLOAD_TITLE));
+      return;
+    case DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED:
+      set_visible(true);
+      set_icon_by_vector_id(gfx::VectorIconId::FILE_DOWNLOAD,
+                            gfx::VectorIconId::BLOCKED_BADGE);
+      set_explanatory_string_id(IDS_BLOCKED_DOWNLOADS_EXPLANATION);
+      set_tooltip(l10n_util::GetStringUTF16(IDS_BLOCKED_DOWNLOAD_TITLE));
+      return;
+    default:
+      // No need to show icon otherwise.
+      return;
+  }
+}
+
 // Base class ------------------------------------------------------------------
 
 gfx::Image ContentSettingImageModel::GetIcon(SkColor nearby_text_color) const {
 #if defined(OS_MACOSX)
   SkColor icon_color = nearby_text_color;
 #else
   SkColor icon_color = color_utils::DeriveDefaultIconColor(nearby_text_color);
 #endif
 
   return gfx::Image(
@@ skipping 22 matching lines @@
         break;
       case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
         model = base::MakeUnique<ContentSettingMediaImageModel>();
         break;
       case CONTENT_SETTINGS_TYPE_SUBRESOURCE_FILTER:
         model = base::MakeUnique<ContentSettingSubresourceFilterImageModel>();
         break;
       case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
         model = base::MakeUnique<ContentSettingMIDISysExImageModel>();
         break;
+      case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS:
+        model = base::MakeUnique<ContentSettingDownloadsImageModel>();
+        break;
       default:
         // All other content settings types use ContentSettingBlockedImageModel.
         model = base::MakeUnique<ContentSettingBlockedImageModel>(icon);
         break;
     }
     result.push_back(std::move(model));
   }
   return result;
 }
 
@@ skipping 12 matching lines @@
 
 #if defined(OS_MACOSX)
 bool ContentSettingImageModel::UpdateFromWebContentsAndCheckIfIconChanged(
     content::WebContents* web_contents) {
   gfx::VectorIconId old_icon = icon_id_;
   gfx::VectorIconId old_badge_icon = icon_badge_id_;
   UpdateFromWebContents(web_contents);
   return old_icon != icon_id_ && old_badge_icon != icon_badge_id_;
 }
 #endif