Use ResourceRequestInfo::GetWebContents in DownloadRequestLimiter

chrome/browser/download/download_resource_throttle.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_resource_throttle.h"
 
 #include "base/bind.h"
 #include "chrome/browser/download/download_stats.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_controller.h"
@@ skipping 12 matching lines @@
 void OnCanDownloadDecided(base::WeakPtr<DownloadResourceThrottle> throttle,
                           bool allow) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&DownloadResourceThrottle::ContinueDownload, throttle, allow));
 }
 
 void CanDownload(
     scoped_ptr<DownloadResourceThrottle::DownloadRequestInfo> info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  info->limiter->CanDownload(info->render_process_id, info->render_view_id,
-                             info->url, info->request_method,
-                             info->continue_callback);
+  info->limiter->CanDownload(info->web_contents_getter, info->url,
+                             info->request_method, info->continue_callback);
 }
 
 #if defined(OS_ANDROID)
 void OnAcquireFileAccessPermissionDone(
     scoped_ptr<DownloadResourceThrottle::DownloadRequestInfo> info,
     bool granted) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (granted)
     CanDownload(info.Pass());
   else
     info->continue_callback.Run(false);
 }
 #endif
 
 void CanDownloadOnUIThread(
     scoped_ptr<DownloadResourceThrottle::DownloadRequestInfo> info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(OS_ANDROID)
-  int process_id = info->render_process_id;
-  int render_view_id = info->render_view_id;
+  content::WebContents* contents = info->web_contents_getter.Run();
+  if (!contents)
+    OnAcquireFileAccessPermissionDone(info.Pass(), false);
   content::DownloadControllerAndroid::Get()->AcquireFileAccessPermission(
-      process_id, render_view_id, base::Bind(&OnAcquireFileAccessPermissionDone,
-                                             base::Passed(info.Pass())));
+      contents, base::Bind(&OnAcquireFileAccessPermissionDone,
+                           base::Passed(info.Pass())));
 #else
   CanDownload(info.Pass());
 #endif
 }
 
 }  // namespace
 
 DownloadResourceThrottle::DownloadRequestInfo::DownloadRequestInfo(
     scoped_refptr<DownloadRequestLimiter> limiter,
-    int render_process_id,
-    int render_view_id,
+    const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& url,
     const std::string& request_method,
     const DownloadRequestLimiter::Callback& continue_callback)
     : limiter(limiter),
-      render_process_id(render_process_id),
-      render_view_id(render_view_id),
+      web_contents_getter(web_contents_getter),
       url(url),
       request_method(request_method),
       continue_callback(continue_callback) {}
 
 DownloadResourceThrottle::DownloadRequestInfo::~DownloadRequestInfo() {}
 
 DownloadResourceThrottle::DownloadResourceThrottle(
     scoped_refptr<DownloadRequestLimiter> limiter,
-    int render_process_id,
-    int render_view_id,
+    const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& url,
     const std::string& request_method)
     : querying_limiter_(true),
       request_allowed_(false),
       request_deferred_(false) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &CanDownloadOnUIThread,
           base::Passed(scoped_ptr<DownloadRequestInfo>(new DownloadRequestInfo(
-              limiter, render_process_id, render_view_id, url, request_method,
+              limiter, web_contents_getter, url, request_method,
               base::Bind(&OnCanDownloadDecided, AsWeakPtr()))))));
 }
 
 DownloadResourceThrottle::~DownloadResourceThrottle() {
 }
 
 void DownloadResourceThrottle::WillStartRequest(bool* defer) {
   WillDownload(defer);
 }
 
@@ skipping 40 matching lines @@
 
   if (request_deferred_) {
     request_deferred_ = false;
     if (allow) {
       controller()->Resume();
     } else {
       controller()->Cancel();
     }
   }
 }