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,

[davidben, 2015/11/24 15:51:16]

Since we're already on the UI thread, I'd probably just cash in the callback now
so the rest of the code needn't deal with it. (I'm thinking dealing with the
callback should be something only code that straddles thread boundaries should
care about. Beyond that, we use proper WebContents pointers and such.)

[clamy, 2015/11/25 14:02:02]

If I do that though I have to get back a RPH + RFH ID so that it can be bound in
the callback in DownloadRequestLimiter::CanDownload. Since there does not seem
to be guarantees on when DownloadRequestLimiter::OnCanDownloadDecided will be
executed, a pointer to WebContents may go out of scope before that. Is that
better than keeping the callback?

+                             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::DownloadControllerAndroid::Get()->AcquireFileAccessPermission(
-      process_id, render_view_id, base::Bind(&OnAcquireFileAccessPermissionDone,
-                                             base::Passed(info.Pass())));
+      info->web_contents_getter.Run(),
+      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 base::Callback<content::WebContents*(void)>& 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 base::Callback<content::WebContents*(void)>& 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();
     }
   }
 }