Adding WebContent-free Download

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 <string>
+#include <vector>
 
 #include "base/callback_forward.h"
 #include "base/containers/hash_tables.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.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/browser/download/url_downloader.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 CONTENT_EXPORT DownloadManagerImpl : public DownloadManager,
                                            private DownloadItemImplDelegate {
  public:
   typedef base::Callback<void(DownloadItemImpl*)> DownloadItemImplCreated;
 
+  class Core {

[asanka, 2015/12/08 16:58:32]

Core classes are usually used when some core functionality requires a different
lifetime than the main object (E.g. we need a refcounted state to attach to some
async operation whose lifetime we don't control).

In the case of DownloadManagerImpl, it's less of a lifetime issue than it is
thread specificity and doesn't cover the core functionality of DownloadManager.
Shall we call it something else? Maybe something like IOThreadState or
DownloadRequestContainer.

Also, if you just have a vector of owned pointers to off thread objects for the
only purpose of deleting them on the correct thread, you can use something like:

  std::vector<scoped_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>>
url_downloaders_;

You can then have this object on the UI thread. Of course you'd need to toss a
scoped_ptr<UrlDownloader> back up to the UI thread after it's created and starts
running.

[svaldez, 2015/12/08 20:39:26]

Done.

+   public:
+    Core();
+    ~Core();
+
+    void AddUrlDownloader(scoped_ptr<UrlDownloader> downloader);
+    void Shutdown();
+
+   private:
+    std::vector<scoped_ptr<UrlDownloader>> url_downloaders_;
+
+    DISALLOW_COPY_AND_ASSIGN(Core);
+  };
+
   // 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);
   ~DownloadManagerImpl() override;
 
   // 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.
@@ skipping 110 matching lines @@
   bool ShouldOpenDownload(DownloadItemImpl* item,
                           const ShouldOpenDownloadCallback& callback) override;
   void CheckForFileRemoval(DownloadItemImpl* download_item) override;
   void ResumeInterruptedDownload(
       scoped_ptr<content::DownloadUrlParameters> params,
       uint32 id) override;
   void OpenDownload(DownloadItemImpl* download) override;
   void ShowDownloadInShell(DownloadItemImpl* download) override;
   void DownloadRemoved(DownloadItemImpl* download) override;
 
+  Core* core_;
+
   // Factory for creation of downloads items.
   scoped_ptr<DownloadItemFactory> item_factory_;
 
   // 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.
@@ skipping 16 matching lines @@
   net::NetLog* net_log_;
 
   base::WeakPtrFactory<DownloadManagerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManagerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_IMPL_H_