Use ResourceRequestInfo::GetWebContents 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/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
@@ skipping 288 matching lines @@
 
   if (!create)
     return NULL;
 
   TabDownloadState* state =
       new TabDownloadState(this, web_contents, originating_web_contents);
   state_map_[web_contents] = state;
   return state;
 }
 
-void DownloadRequestLimiter::CanDownload(int render_process_host_id,
-                                         int render_view_id,
-                                         const GURL& url,
-                                         const std::string& request_method,
-                                         const Callback& callback) {
+void DownloadRequestLimiter::CanDownload(
+    const base::Callback<content::WebContents*(void)>& web_contents_getter,
+    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);
+  content::WebContents* originating_contents = web_contents_getter.Run();
   if (!originating_contents) {
     // The WebContents was closed, don't allow the download.
     callback.Run(false);
     return;
   }
 
   if (!originating_contents->GetDelegate()) {
     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);
+      &DownloadRequestLimiter::OnCanDownloadDecided, factory_.GetWeakPtr(),
+      web_contents_getter, 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 base::Callback<content::WebContents*(void)>& web_contents_getter,
     const std::string& request_method,
-    const Callback& orig_callback, bool allow) {
+    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);
+  content::WebContents* originating_contents = web_contents_getter.Run();
   if (!originating_contents || !allow) {
     orig_callback.Run(false);
     return;
   }
 
   CanDownloadImpl(originating_contents,
                   request_method,
                   orig_callback);
 }
 
@@ skipping 79 matching lines @@
       NOTREACHED();
   }
 }
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state,
                                     content::WebContents* contents) {
   DCHECK(ContainsKey(state_map_, contents));
   state_map_.erase(contents);
   delete state;
 }