Don't destroy a request while it is being processed

chrome/browser/download/download_request_limiter.cc

 // Copyright (c) 2011 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/stl_util-inl.h"
 #include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "content/browser/browser_thread.h"
@@ skipping 172 matching lines @@
 }
 
 DownloadRequestLimiter::DownloadStatus
     DownloadRequestLimiter::GetDownloadStatus(TabContents* tab) {
   TabDownloadState* state = GetDownloadState(&tab->controller(), NULL, false);
   return state ? state->download_status() : ALLOW_ONE_DOWNLOAD;
 }
 
 void DownloadRequestLimiter::CanDownloadOnIOThread(int render_process_host_id,
                                                    int render_view_id,
+                                                   int request_id,
                                                    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(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadRequestLimiter::CanDownload,
-                        render_process_host_id, render_view_id, callback));
+                        render_process_host_id, render_view_id, request_id,
+                        callback));
 }
 
 void DownloadRequestLimiter::OnUserGesture(TabContents* tab) {
   TabDownloadState* state = GetDownloadState(&tab->controller(), NULL, false);
   if (!state)
     return;
 
   state->OnUserGesture();
 }
 
@@ skipping 15 matching lines @@
     return NULL;
 
   TabDownloadState* state =
       new TabDownloadState(this, controller, originating_controller);
   state_map_[controller] = state;
   return state;
 }
 
 void DownloadRequestLimiter::CanDownload(int render_process_host_id,
                                          int render_view_id,
+                                         int request_id,
                                          Callback* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TabContents* originating_tab =
       tab_util::GetTabContentsByID(render_process_host_id, render_view_id);
   if (!originating_tab) {
     // The tab was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
-  CanDownloadImpl(originating_tab, callback);
+  CanDownloadImpl(originating_tab, request_id, callback);
 }
 
 void DownloadRequestLimiter::CanDownloadImpl(
     TabContents* originating_tab,
+    int request_id,
     Callback* callback) {
   // FYI: Chrome Frame overrides CanDownload in ExternalTabContainer in order
   // to cancel the download operation in chrome and let the host browser
   // take care of it.
-  if (!originating_tab->CanDownload(callback->GetRequestId())) {
+  if (!originating_tab->CanDownload(request_id)) {
     ScheduleNotification(callback, false);
     return;
   }
 
   // If the tab requesting the download is a constrained popup that is not
   // shown, treat the request as if it came from the parent.
   TabContents* effective_tab = originating_tab;
   if (effective_tab->delegate()) {
     effective_tab =
         effective_tab->delegate()->GetConstrainingContents(effective_tab);
@@ skipping 47 matching lines @@
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state) {
   DCHECK(ContainsKey(state_map_, state->controller()));
   state_map_.erase(state->controller());
   delete state;
 }
 
 // static
 DownloadRequestLimiter::TestingDelegate* DownloadRequestLimiter::delegate_ =
     NULL;