Don't destroy a request while it is being processed

chrome/browser/download/download_request_limiter.h

 // 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.
 
 #ifndef CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_
 #define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 41 matching lines @@
   };
 
   // Max number of downloads before a "Prompt Before Download" Dialog is shown.
   static const size_t kMaxDownloadsAtOnce = 50;
 
   // The callback from CanDownloadOnIOThread. This is invoked on the io thread.
   class Callback {
    public:
     virtual void ContinueDownload() = 0;
     virtual void CancelDownload() = 0;
-    virtual int GetRequestId() = 0;
 
    protected:
     virtual ~Callback() {}
   };
 
   // TabDownloadState maintains the download state for a particular tab.
   // TabDownloadState prompts the user with an infobar as necessary.
   // TabDownloadState deletes itself (by invoking
   // DownloadRequestLimiter::Remove) as necessary.
   class TabDownloadState : public NotificationObserver {
@@ skipping 98 matching lines @@
   // anyway.
   DownloadStatus GetDownloadStatus(TabContents* tab);
 
   // Updates the state of the page as necessary and notifies the callback.
   // WARNING: both this call and the callback are invoked on the io thread.
   //
   // DownloadRequestLimiter does not retain/release the Callback. It is up to
   // the caller to ensure the callback is valid until the request is complete.
   void CanDownloadOnIOThread(int render_process_host_id,
                              int render_view_id,
+                             int request_id,
                              Callback* callback);
 
   // Invoked when the user presses the mouse, enter key or space bar. This may
   // change the download status for the page. See the class description for
   // details.
   void OnUserGesture(TabContents* tab);
 
  private:
   friend class base::RefCountedThreadSafe<DownloadRequestLimiter>;
   friend class DownloadRequestLimiterTest;
@@ skipping 20 matching lines @@
   // deleted when no longer needed (the Remove method is invoked).
   TabDownloadState* GetDownloadState(
       NavigationController* controller,
       NavigationController* originating_controller,
       bool create);
 
   // CanDownloadOnIOThread invokes this on the UI thread. This determines the
   // tab and invokes CanDownloadImpl.
   void CanDownload(int render_process_host_id,
                    int render_view_id,
+                   int request_id,
                    Callback* callback);
 
   // Does the work of updating the download status on the UI thread and
   // potentially prompting the user.
   void CanDownloadImpl(TabContents* originating_tab,
+                       int request_id,
                        Callback* callback);
 
   // Invoked on the UI thread. Schedules a call to NotifyCallback on the io
   // thread.
   void ScheduleNotification(Callback* callback, bool allow);
 
   // Notifies the callback. This *must* be invoked on the IO thread.
   void NotifyCallback(Callback* callback, bool allow);
 
   // Removes the specified TabDownloadState from the internal map and deletes
   // it. This has the effect of resetting the status for the tab to
   // ALLOW_ONE_DOWNLOAD.
   void Remove(TabDownloadState* state);
 
   // Maps from tab to download state. The download state for a tab only exists
   // if the state is other than ALLOW_ONE_DOWNLOAD. Similarly once the state
   // transitions from anything but ALLOW_ONE_DOWNLOAD back to ALLOW_ONE_DOWNLOAD
   // the TabDownloadState is removed and deleted (by way of Remove).
   typedef std::map<NavigationController*, TabDownloadState*> StateMap;
   StateMap state_map_;
 
   static TestingDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadRequestLimiter);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_REQUEST_LIMITER_H_