move file access permission logic to DownloadResourceThrottle

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/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/download/download_permission_request.h"
@@ skipping 229 matching lines @@
     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;
   }
 
-  for (size_t i = 0; i < callbacks.size(); ++i)
-    host_->ScheduleNotification(callbacks[i], allow);
+  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);
 }
 
 // DownloadRequestLimiter ------------------------------------------------------
 
 HostContentSettingsMap* DownloadRequestLimiter::content_settings_ = NULL;
 
 void DownloadRequestLimiter::SetContentSettingsForTesting(
@@ skipping 10 matching lines @@
   // removes from state_map_. As such, there should be no pending callbacks.
   DCHECK(state_map_.empty());
 }
 
 DownloadRequestLimiter::DownloadStatus
 DownloadRequestLimiter::GetDownloadStatus(content::WebContents* web_contents) {
   TabDownloadState* state = GetDownloadState(web_contents, NULL, false);
   return state ? state->download_status() : ALLOW_ONE_DOWNLOAD;
 }
 
-void DownloadRequestLimiter::CanDownloadOnIOThread(
-    int render_process_host_id,
-    int render_view_id,
-    const GURL& url,
-    const std::string& request_method,
-    const Callback& callback) {
-  // This is invoked on the IO thread. Schedule the task to run on the UI
-  // thread so that we can query UI state.
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DownloadRequestLimiter::CanDownload, this,
-                 render_process_host_id, render_view_id, url,
-                 request_method, callback));
-}
-
 DownloadRequestLimiter::TabDownloadState*
 DownloadRequestLimiter::GetDownloadState(
     content::WebContents* web_contents,
     content::WebContents* originating_web_contents,
     bool create) {
   DCHECK(web_contents);
   StateMap::iterator i = state_map_.find(web_contents);
   if (i != state_map_.end())
     return i->second;
 
@@ skipping 10 matching lines @@
                                          int render_view_id,
                                          const GURL& url,
                                          const std::string& request_method,
                                          const Callback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents) {
     // The WebContents was closed, don't allow the download.
-    ScheduleNotification(callback, false);
+    callback.Run(false);
     return;
   }
 
   if (!originating_contents->GetDelegate()) {
-    ScheduleNotification(callback, false);
+    callback.Run(false);
     return;
   }
 
   // Note that because |originating_contents| might go away before
   // OnCanDownloadDecided is invoked, we look it up by |render_process_host_id|
   // and |render_view_id|.
   base::Callback<void(bool)> can_download_callback = base::Bind(
       &DownloadRequestLimiter::OnCanDownloadDecided,
       factory_.GetWeakPtr(),
       render_process_host_id,
       render_view_id,
       request_method,
       callback);
 
   originating_contents->GetDelegate()->CanDownload(
       url,
       request_method,
       can_download_callback);
 }
 
 void DownloadRequestLimiter::OnCanDownloadDecided(
     int render_process_host_id,
     int render_view_id,
     const std::string& request_method,
     const Callback& orig_callback, bool allow) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents || !allow) {
-    ScheduleNotification(orig_callback, false);
+    orig_callback.Run(false);
     return;
   }
 
   CanDownloadImpl(originating_contents,
                   request_method,
                   orig_callback);
 }
 
 HostContentSettingsMap* DownloadRequestLimiter::GetContentSettings(
     content::WebContents* contents) {
   return content_settings_ ? content_settings_ : Profile::FromBrowserContext(
       contents->GetBrowserContext())->GetHostContentSettingsMap();
 }
 
 void DownloadRequestLimiter::CanDownloadImpl(
     content::WebContents* originating_contents,
     const std::string& request_method,
     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);
-      ScheduleNotification(callback, true);
+      callback.Run(true);
       state->increment_download_count();
       break;
 
     case ALLOW_ONE_DOWNLOAD:
       state->set_download_status(PROMPT_BEFORE_DOWNLOAD);
-      ScheduleNotification(callback, true);
+      callback.Run(true);
       state->increment_download_count();
       break;
 
     case DOWNLOADS_NOT_ALLOWED:
-      ScheduleNotification(callback, false);
+      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);
-          ScheduleNotification(callback, true);
+          callback.Run(true);
           state->increment_download_count();
           return;
         }
         case CONTENT_SETTING_BLOCK: {
           TabSpecificContentSettings* settings =
               TabSpecificContentSettings::FromWebContents(
                   originating_contents);
           if (settings)
             settings->SetDownloadsBlocked(true);
-          ScheduleNotification(callback, false);
+          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::ScheduleNotification(const Callback& callback,
-                                                  bool allow) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(callback, allow));
-}
-
 void DownloadRequestLimiter::Remove(TabDownloadState* state,
                                     content::WebContents* contents) {
   DCHECK(ContainsKey(state_map_, contents));
   state_map_.erase(contents);
   delete state;
 }