WIP - Refactor programmatic downloads

content/browser/download/download_manager_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_IMPL_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_IMPL_H_
 
 #include <map>
 #include <set>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/synchronization/lock.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/download_url_parameters.h"
 
 namespace net {
 class BoundNetLog;
 }
 
 namespace content {
 class DownloadFileFactory;
 class DownloadItemFactory;
 class DownloadItemImpl;
-class DownloadRequestHandleInterface;
+class DownloadRequestHandle;
 
 class CONTENT_EXPORT DownloadManagerImpl : public DownloadManager,
                                            private DownloadItemImplDelegate {
  public:
   typedef base::Callback<void(DownloadItemImpl*)> DownloadItemImplCreated;
 
   // Caller guarantees that |net_log| will remain valid
   // for the lifetime of DownloadManagerImpl (until Shutdown() is called).
   DownloadManagerImpl(net::NetLog* net_log, BrowserContext* browser_context);
   virtual ~DownloadManagerImpl();
 
   // Implementation functions (not part of the DownloadManager interface).
-
-  // Creates a download item for the SavePackage system.
-  // Must be called on the UI thread.  Note that the DownloadManager
-  // retains ownership.
   virtual void CreateSavePackageDownloadItem(
-      const base::FilePath& main_file_path,
-      const GURL& page_url,
-      const std::string& mime_type,
-      scoped_ptr<DownloadRequestHandleInterface> request_handle,
-      const DownloadItemImplCreated& item_created);
+      scoped_ptr<DownloadCreateInfo> info,
+      const DownloadItemImplCreated& created_callback);
 
   // Notifies DownloadManager about a successful completion of |download_item|.
   void OnSavePackageSuccessfullyFinished(DownloadItem* download_item);
 
   // DownloadManager functions.
   virtual void SetDelegate(DownloadManagerDelegate* delegate) OVERRIDE;
   virtual DownloadManagerDelegate* GetDelegate() const OVERRIDE;
   virtual void Shutdown() OVERRIDE;
   virtual void GetAllDownloads(DownloadVector* result) OVERRIDE;
-  virtual void StartDownload(
-      scoped_ptr<DownloadCreateInfo> info,
-      scoped_ptr<ByteStreamReader> stream,
-      const DownloadUrlParameters::OnStartedCallback& on_started) OVERRIDE;
+  virtual void StartDownloadWithActiveRequest(
+      scoped_ptr<DownloadRequestHandle> request_handle,
+      scoped_ptr<DownloadCreateInfo> info) OVERRIDE;
   virtual int RemoveDownloadsBetween(base::Time remove_begin,
                                      base::Time remove_end) OVERRIDE;
   virtual int RemoveDownloads(base::Time remove_begin) OVERRIDE;
   virtual int RemoveAllDownloads() OVERRIDE;
   virtual void DownloadUrl(scoped_ptr<DownloadUrlParameters> params) OVERRIDE;
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual content::DownloadItem* CreateDownloadItem(
       uint32 id,
       const base::FilePath& current_path,
@@ skipping 24 matching lines @@
 
  private:
   typedef std::set<DownloadItem*> DownloadSet;
   typedef base::hash_map<uint32, DownloadItemImpl*> DownloadMap;
   typedef std::vector<DownloadItemImpl*> DownloadItemImplVector;
 
   // For testing.
   friend class DownloadManagerTest;
   friend class DownloadTest;
 
-  void StartDownloadWithId(
-      scoped_ptr<DownloadCreateInfo> info,
-      scoped_ptr<ByteStreamReader> stream,
+  DownloadItemImpl* UpdateAndGetResumedDownloadItem(
+      uint32 download_id,
+      DownloadRequestHandle* request_handle,
+      const DownloadCreateInfo& new_create_info);
+
+  void DownloadUrlWithId(scoped_ptr<DownloadUrlParameters> params,
+                         bool new_download,
+                         uint32 download_id);
+
+  void OnDownloadRequestStarted(
+      uint32 download_id,
+      bool new_download,
       const DownloadUrlParameters::OnStartedCallback& on_started,
-      bool new_download,
-      uint32 id);
+      DownloadRequestHandle* request_handle,
+      DownloadInterruptReason interrupt_reason,
+      scoped_ptr<DownloadCreateInfo> create_info);
+
+  void StartDownloadWithId(scoped_ptr<DownloadRequestHandle> request_handle,
+                           scoped_ptr<DownloadCreateInfo> info,
+                           uint32 id);
 
   void CreateSavePackageDownloadItemWithId(
-      const base::FilePath& main_file_path,
-      const GURL& page_url,
-      const std::string& mime_type,
-      scoped_ptr<DownloadRequestHandleInterface> request_handle,
-      const DownloadItemImplCreated& on_started,
+      scoped_ptr<DownloadCreateInfo> info,
+      const DownloadItemImplCreated& download_created_callback,
       uint32 id);
 
   // Create a new active item based on the info.  Separate from
   // StartDownload() for testing.
-  DownloadItemImpl* CreateActiveItem(uint32 id,
-                                     const DownloadCreateInfo& info);
+  DownloadItemImpl* CreateActiveItem(uint32 id, const DownloadCreateInfo& info);
 
   // Get next download id. |callback| is called on the UI thread and may
   // be called synchronously.
   void GetNextId(const DownloadIdCallback& callback);
 
   // Called with the result of DownloadManagerDelegate::CheckForFileExistence.
   // Updates the state of the file and then notifies this update to the file's
   // observer.
   void OnFileExistenceChecked(uint32 download_id, bool result);
 
@@ skipping 21 matching lines @@
 
   // Factory for the creation of download files.
   scoped_ptr<DownloadFileFactory> file_factory_;
 
   // |downloads_| is the owning set for all downloads known to the
   // DownloadManager.  This includes downloads started by the user in
   // this session, downloads initialized from the history system, and
   // "save page as" downloads.
   DownloadMap downloads_;
 
+  // Handles to programmatic download requests that are still pending.  These
+  // are kept here so that if the DownloadManager were to be destroyed while the
+  // requests are still pending, the associated handles and, by extension, the
+  // URLRequest will also be destroyed.
+  //
+  // TODO(asanka): Move towards model of constructing the DownloadItem early and
+  // then having the DownloadItem own the request handle.
+  ScopedVector<DownloadRequestHandle> pending_requests_;
+
   int history_size_;
 
   // True if the download manager has been initialized and requires a shutdown.
   bool shutdown_needed_;
 
   // Observers that want to be notified of changes to the set of downloads.
   ObserverList<Observer> observers_;
 
   // The current active browser context.
   BrowserContext* browser_context_;
 
   // Allows an embedder to control behavior. Guaranteed to outlive this object.
   DownloadManagerDelegate* delegate_;
 
   net::NetLog* net_log_;
 
   base::WeakPtrFactory<DownloadManagerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManagerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_IMPL_H_