Handle per-tab AUTOMATIC_DOWNLOADS setting in DownloadRequestLimiter.

chrome/browser/download/download_request_limiter.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/download/download_request_limiter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chrome_notification_types.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/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "components/content_settings/core/browser/content_settings_details.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/browser/notification_types.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/download/download_request_infobar_delegate_android.h"
 #else
 #include "chrome/browser/download/download_permission_request.h"
 #include "chrome/browser/permissions/permission_request_manager.h"
 #endif
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 
+namespace {
+
+ContentSetting GetSettingFromStatus(
+    DownloadRequestLimiter::DownloadStatus status) {
+  switch (status) {
+    case DownloadRequestLimiter::ALLOW_ONE_DOWNLOAD:
+    case DownloadRequestLimiter::PROMPT_BEFORE_DOWNLOAD:
+      return CONTENT_SETTING_ASK;
+    case DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS:
+      return CONTENT_SETTING_ALLOW;
+    case DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED:
+      return CONTENT_SETTING_BLOCK;
+    default:
+      NOTREACHED();
+      return CONTENT_SETTING_DEFAULT;
+  }
+}
+
+DownloadRequestLimiter::DownloadStatus GetStatusFromSetting(
+    ContentSetting setting) {
+  switch (setting) {
+    case CONTENT_SETTING_ALLOW:
+      return DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS;
+    case CONTENT_SETTING_BLOCK:
+      return DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED;
+    case CONTENT_SETTING_ASK:
+    case CONTENT_SETTING_DEFAULT:

[Bernhard Bauer, 2017/01/25 19:01:14]

Are these content settings actually used? DEFAULT should only be used to signal
the absence of a specific setting, and SESSION_ONLY is only used for cookies.

[alshabalin, 2017/02/07 16:16:29]

Added NOTREACHED() for SESSION_ONLY. But left the DEFAULT untouched for I'm not
sure if it can arrive here or not.

+    case CONTENT_SETTING_SESSION_ONLY:
+      return DownloadRequestLimiter::PROMPT_BEFORE_DOWNLOAD;
+    case CONTENT_SETTING_NUM_SETTINGS:
+    case CONTENT_SETTING_DETECT_IMPORTANT_CONTENT:
+      NOTREACHED();
+      return DownloadRequestLimiter::PROMPT_BEFORE_DOWNLOAD;
+  }
+}
+
+}  // namespace
+
 // TabDownloadState ------------------------------------------------------------
 
 DownloadRequestLimiter::TabDownloadState::TabDownloadState(
     DownloadRequestLimiter* host,
     content::WebContents* contents,
     content::WebContents* originating_web_contents)
     : content::WebContentsObserver(contents),
       web_contents_(contents),
       host_(host),
       status_(DownloadRequestLimiter::ALLOW_ONE_DOWNLOAD),
       download_count_(0),
+      observer_(this),
       factory_(this) {
-  registrar_.Add(this, chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
-                 content::Source<content::WebContents>(contents));
+  observer_.Add(DownloadRequestLimiter::GetContentSettings(contents));

[Bernhard Bauer, 2017/01/25 19:01:14]

The DownloadRequestLimiter:: prefix doesn't seem necessary if you are already
inside the class.

[alshabalin, 2017/02/07 16:16:29]

Done.

   NavigationEntry* last_entry =
       originating_web_contents
           ? originating_web_contents->GetController().GetLastCommittedEntry()
           : contents->GetController().GetLastCommittedEntry();
   if (last_entry)
     initial_page_host_ = last_entry->GetURL().host();
 }
 
 DownloadRequestLimiter::TabDownloadState::~TabDownloadState() {
   // We should only be destroyed after the callbacks have been notified.
   DCHECK(callbacks_.empty());
 
   // And we should have invalidated the back pointer.
   DCHECK(!factory_.HasWeakPtrs());
 }
 
+void DownloadRequestLimiter::TabDownloadState::SetDownloadStatusAndNotify(
+    DownloadRequestLimiter::DownloadStatus status) {
+  DownloadStatus last_status = status_;
+  status_ = status;
+  if (!web_contents())
+    return;
+  ContentSetting last_setting = GetSettingFromStatus(last_status);
+  ContentSetting current_setting = GetSettingFromStatus(status_);
+  if (current_setting == last_setting)
+    return;
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
+      content::Source<content::WebContents>(web_contents()),
+      content::NotificationService::NoDetails());
+}
+
 void DownloadRequestLimiter::TabDownloadState::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
 
   // If the navigation is renderer-initiated (but not user-initiated), ensure
   // that a prompting or blocking limiter state is not reset, so
   // window.location.href or meta refresh can't be abused to avoid the limiter.
   // User-initiated navigations will trigger DidGetUserInteraction, which resets
   // the limiter before the navigation starts.
@@ skipping 107 matching lines @@
       DownloadRequestLimiter::GetContentSettings(web_contents_);
   if (!settings)
     return;
   settings->SetContentSettingDefaultScope(
       web_contents_->GetURL(), GURL(),
       CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, std::string(), setting);
 }
 
 void DownloadRequestLimiter::TabDownloadState::Cancel() {
   SetContentSetting(CONTENT_SETTING_BLOCK);
-  NotifyCallbacks(false);
+  bool throttled = NotifyCallbacks(false);
+  SetDownloadStatusAndNotify(throttled ? PROMPT_BEFORE_DOWNLOAD
+                                       : DOWNLOADS_NOT_ALLOWED);
 }
 
 void DownloadRequestLimiter::TabDownloadState::CancelOnce() {
-  NotifyCallbacks(false);
+  bool throttled = NotifyCallbacks(false);
+  SetDownloadStatusAndNotify(throttled ? PROMPT_BEFORE_DOWNLOAD
+                                       : DOWNLOADS_NOT_ALLOWED);
 }
 
 void DownloadRequestLimiter::TabDownloadState::Accept() {
   SetContentSetting(CONTENT_SETTING_ALLOW);
-  NotifyCallbacks(true);
+  bool throttled = NotifyCallbacks(true);
+  SetDownloadStatusAndNotify(throttled ? PROMPT_BEFORE_DOWNLOAD
+                                       : ALLOW_ALL_DOWNLOADS);
 }
 
 DownloadRequestLimiter::TabDownloadState::TabDownloadState()
     : web_contents_(NULL),
       host_(NULL),
       status_(DownloadRequestLimiter::ALLOW_ONE_DOWNLOAD),
       download_count_(0),
+      observer_(this),
       factory_(this) {}
 
 bool DownloadRequestLimiter::TabDownloadState::is_showing_prompt() const {
   return factory_.HasWeakPtrs();
 }
 
-void DownloadRequestLimiter::TabDownloadState::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED, type);
+void DownloadRequestLimiter::TabDownloadState::OnContentSettingChanged(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type,
+    std::string resource_identifier) {
+  if (content_type != CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS)
+    return;
+
+  // Analogous to TabSpecificContentSettings::OnContentSettingChanged:
+  const ContentSettingsDetails details(primary_pattern, secondary_pattern,
+                                       content_type, resource_identifier);
+  const NavigationController& controller = web_contents()->GetController();
+  // The visible NavigationEntry is the URL in the URL field of a tab.
+  // Currently this should be matched by the |primary_pattern|.
+  NavigationEntry* entry = controller.GetVisibleEntry();
+  GURL entry_url;
+  if (entry)
+    entry_url = entry->GetURL();
+  if (!details.update_all() && !details.primary_pattern().Matches(entry_url))
+    return;
 
   // Content settings have been updated for our web contents, e.g. via the OIB
   // or the settings page. Check to see if the automatic downloads setting is
   // different to our internal state, and update the internal state to match if
   // necessary. If there is no content setting persisted, then retain the
   // current state and do nothing.
   //
   // NotifyCallbacks is not called as this notification should be triggered when
   // a download is not pending.
-  content::WebContents* contents =
-      content::Source<content::WebContents>(source).ptr();
-  DCHECK_EQ(contents, web_contents());
-
+  //
   // Fetch the content settings map for this web contents, and extract the
   // automatic downloads permission value.
-  HostContentSettingsMap* content_settings = GetContentSettings(contents);
+  HostContentSettingsMap* content_settings = GetContentSettings(web_contents());
   if (!content_settings)
     return;
 
   ContentSetting setting = content_settings->GetContentSetting(
-      contents->GetURL(), contents->GetURL(),
+      web_contents()->GetURL(), web_contents()->GetURL(),
       CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, std::string());
 
   // Update the internal state to match if necessary.
-  switch (setting) {
-    case CONTENT_SETTING_ALLOW:
-      set_download_status(ALLOW_ALL_DOWNLOADS);
-      break;
-    case CONTENT_SETTING_BLOCK:
-      set_download_status(DOWNLOADS_NOT_ALLOWED);
-      break;
-    case CONTENT_SETTING_ASK:
-    case CONTENT_SETTING_DEFAULT:
-    case CONTENT_SETTING_SESSION_ONLY:
-      set_download_status(PROMPT_BEFORE_DOWNLOAD);
-      break;
-    case CONTENT_SETTING_NUM_SETTINGS:
-    case CONTENT_SETTING_DETECT_IMPORTANT_CONTENT:
-      NOTREACHED();
-      return;
-  }
+  SetDownloadStatusAndNotify(GetStatusFromSetting(setting));

[Bernhard Bauer, 2017/01/25 19:01:14]

Here you convert the setting to a status, and the first thing
SetDownloadStatusAndNotify() does is convert it back to a content setting. Would
it make more sense to directly pass a content setting? Or alternatively,
directly compare statuses in SetDownloadStatusAndNotify()?

[alshabalin, 2017/02/07 16:16:29]

Added UpdateDownloadStatusAndNotify taking ContentSetting instead of
DownloadStatus. I've chosen to compare settings instead of statuses, because
transition ALLOW_ONE -> PROMPT does not change the actual setting and so doesn't
need to fire a global notification.

 }
 
-void DownloadRequestLimiter::TabDownloadState::NotifyCallbacks(bool allow) {
-  set_download_status(allow ? DownloadRequestLimiter::ALLOW_ALL_DOWNLOADS
-                            : DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED);
+bool DownloadRequestLimiter::TabDownloadState::NotifyCallbacks(bool allow) {
   std::vector<DownloadRequestLimiter::Callback> callbacks;
-  bool change_status = false;
+  bool throttled = false;
 
   // Selectively send first few notifications only if number of downloads exceed
   // kMaxDownloadsAtOnce. In that case, we also retain the infobar instance and
   // don't close it. If allow is false, we send all the notifications to cancel
   // all remaining downloads and close the infobar.
   if (!allow || (callbacks_.size() < kMaxDownloadsAtOnce)) {
     // Null the generated weak pointer so we don't get notified again.
     factory_.InvalidateWeakPtrs();
     callbacks.swap(callbacks_);
   } else {
     std::vector<DownloadRequestLimiter::Callback>::iterator start, end;
     start = callbacks_.begin();
     end = callbacks_.begin() + kMaxDownloadsAtOnce;
     callbacks.assign(start, end);
     callbacks_.erase(start, end);
-    change_status = true;
+    throttled = true;
   }
 
   for (const auto& callback : callbacks) {
     // When callback runs, it can cause the WebContents to be destroyed.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback, allow));
   }
 
-  if (change_status)
-    set_download_status(DownloadRequestLimiter::PROMPT_BEFORE_DOWNLOAD);
+  return throttled;
 }
 
 // DownloadRequestLimiter ------------------------------------------------------
 
 HostContentSettingsMap* DownloadRequestLimiter::content_settings_ = NULL;
 
 void DownloadRequestLimiter::SetContentSettingsForTesting(
     HostContentSettingsMap* content_settings) {
   content_settings_ = content_settings;
 }
@@ skipping 90 matching lines @@
     const Callback& callback) {
   DCHECK(originating_contents);
 
   TabDownloadState* state =
       GetDownloadState(originating_contents, originating_contents, true);
   switch (state->download_status()) {
     case ALLOW_ALL_DOWNLOADS:
       if (state->download_count() &&
           !(state->download_count() %
             DownloadRequestLimiter::kMaxDownloadsAtOnce))
-        state->set_download_status(PROMPT_BEFORE_DOWNLOAD);
+        state->SetDownloadStatusAndNotify(PROMPT_BEFORE_DOWNLOAD);
       callback.Run(true);
       state->increment_download_count();
       break;
 
     case ALLOW_ONE_DOWNLOAD:
-      state->set_download_status(PROMPT_BEFORE_DOWNLOAD);
+      state->SetDownloadStatusAndNotify(PROMPT_BEFORE_DOWNLOAD);
       callback.Run(true);
       state->increment_download_count();
       break;
 
     case DOWNLOADS_NOT_ALLOWED:
       callback.Run(false);
       break;
 
     case PROMPT_BEFORE_DOWNLOAD: {
       HostContentSettingsMap* content_settings =
           GetContentSettings(originating_contents);
       ContentSetting setting = CONTENT_SETTING_ASK;
       if (content_settings)
         setting = content_settings->GetContentSetting(
             originating_contents->GetURL(), originating_contents->GetURL(),
             CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, std::string());
       switch (setting) {
         case CONTENT_SETTING_ALLOW: {
-          TabSpecificContentSettings* settings =
-              TabSpecificContentSettings::FromWebContents(originating_contents);
-          if (settings)
-            settings->SetDownloadsBlocked(false);
+          state->SetDownloadStatusAndNotify(ALLOW_ALL_DOWNLOADS);
           callback.Run(true);
           state->increment_download_count();
           return;
         }
         case CONTENT_SETTING_BLOCK: {
-          TabSpecificContentSettings* settings =
-              TabSpecificContentSettings::FromWebContents(originating_contents);
-          if (settings)
-            settings->SetDownloadsBlocked(true);
+          state->SetDownloadStatusAndNotify(DOWNLOADS_NOT_ALLOWED);
           callback.Run(false);
           return;
         }
         case CONTENT_SETTING_DEFAULT:
         case CONTENT_SETTING_ASK:
         case CONTENT_SETTING_SESSION_ONLY:
           state->PromptUserForDownload(callback);
           state->increment_download_count();
           break;
         case CONTENT_SETTING_NUM_SETTINGS:
         default:
           NOTREACHED();
           return;
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state,
                                     content::WebContents* contents) {
   DCHECK(base::ContainsKey(state_map_, contents));
   state_map_.erase(contents);
   delete state;
 }