DownloadId

content/browser/download/download_manager.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 "content/browser/download/download_manager.h"
 
 #include <iterator>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "base/stringprintf.h"
+#include "base/synchronization/lock.h"
+#include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "content/browser/browser_context.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_item.h"
 #include "content/browser/download/download_manager_delegate.h"
 #include "content/browser/download/download_persistent_store_info.h"
@@ skipping 19 matching lines @@
       url, referrer, save_info, true, render_process_id, render_view_id,
       *context);
 }
 
 }  // namespace
 
 DownloadManager::DownloadManager(DownloadManagerDelegate* delegate,
                                  DownloadStatusUpdater* status_updater)
     : shutdown_needed_(false),
       browser_context_(NULL),
+      next_id_(0),
       file_manager_(NULL),
-      status_updater_(status_updater->AsWeakPtr()),
+      status_updater_((status_updater != NULL)
+                      ? status_updater->AsWeakPtr()
+                      : base::WeakPtr<DownloadStatusUpdater>()),
       delegate_(delegate),
       largest_db_handle_in_history_(DownloadItem::kUninitializedHandle) {
-  if (status_updater_)
+  // NOTE(benjhayden): status_updater may be NULL when using
+  // TestingBrowserProcess.
+  if (status_updater_.get() != NULL)
     status_updater_->AddDelegate(this);
 }
 
 DownloadManager::~DownloadManager() {
   DCHECK(!shutdown_needed_);
-  if (status_updater_)
+  if (status_updater_.get() != NULL)
     status_updater_->RemoveDelegate(this);
 }
 
 void DownloadManager::Shutdown() {
   VLOG(20) << __FUNCTION__ << "()"
            << " shutdown_needed_ = " << shutdown_needed_;
   if (!shutdown_needed_)
     return;
   shutdown_needed_ = false;
 
@@ skipping 47 matching lines @@
   in_progress_.clear();
   active_downloads_.clear();
   history_downloads_.clear();
   STLDeleteElements(&downloads_to_delete);
 
   DCHECK(save_page_downloads_.empty());
 
   file_manager_ = NULL;
   delegate_->Shutdown();
 
   shutdown_needed_ = false;

[Randy Smith (Not in Mondays), 2011/09/09 20:56:00]

Why eliminate this line?  My memory is that we rely on it elsewhere in the file
...

[benjhayden, 2011/09/09 21:13:33]

It's redundant to L81.
I'd rather keep the one on L81 because it's closer to its usage on L79.

 }
 
 void DownloadManager::GetTemporaryDownloads(
     const FilePath& dir_path, DownloadVector* result) {
   DCHECK(result);
 
   for (DownloadMap::iterator it = history_downloads_.begin();
        it != history_downloads_.end(); ++it) {
     if (it->second->is_temporary() &&
         it->second->full_path().DirName() == dir_path)
@@ skipping 28 matching lines @@
     // The Incognito Downloads page will get the list of non-Incognito downloads
     // from its parent profile.
     if (browser_context_->IsOffTheRecord() != download_item->is_otr())
       continue;
 
     if (download_item->MatchesQuery(query_lower))
       result->push_back(download_item);
   }
 }
 
+void DownloadManager::OnPersistentStoreGetNextId(int next_id) {
+  DVLOG(1) << __FUNCTION__ << " " << next_id;
+  base::AutoLock lock(next_id_lock_);
+  // TODO(benjhayden) Delay Profile initialization until here, and set next_id_
+  // = next_id. The '+=' works for now because these ids are not yet persisted
+  // to the database. GetNextId() can allocate zero or more ids starting from 0,
+  // then this callback can increment next_id_, and the items with lower ids
+  // won't clash with any other items even though there may be items loaded from
+  // the history because items from the history don't have valid ids.
+  next_id_ += next_id;
+}
+
+DownloadId DownloadManager::GetNextId() {
+  // May be called on any thread via the GetNextIdThunk.
+  // TODO(benjhayden) If otr, forward to parent DM.
+  base::AutoLock lock(next_id_lock_);
+  return DownloadId(this, next_id_++);
+}
+
+DownloadManager::GetNextIdThunkType DownloadManager::GetNextIdThunk() {
+  // TODO(benjhayden) If otr, forward to parent DM.
+  return base::Bind(&DownloadManager::GetNextId, this);
+}
+
 // Query the history service for information about all persisted downloads.
 bool DownloadManager::Init(content::BrowserContext* browser_context) {
   DCHECK(browser_context);
   DCHECK(!shutdown_needed_)  << "DownloadManager already initialized.";
   shutdown_needed_ = true;
 
   browser_context_ = browser_context;
 
   // In test mode, there may be no ResourceDispatcherHost.  In this case it's
   // safe to avoid setting |file_manager_| because we only call a small set of
@@ skipping 131 matching lines @@
 
   // Rename to intermediate name.
   FilePath download_path;
   if (!delegate_->OverrideIntermediatePath(download, &download_path))
     download_path = download->full_path();
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::RenameInProgressDownloadFile,
-          download->id(), download_path));
+          download->global_id(), download_path));
 
   download->Rename(download_path);
 
   delegate_->AddItemToPersistentStore(download);
 }
 
 void DownloadManager::UpdateDownload(int32 download_id, int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadMap::iterator it = active_downloads_.find(download_id);
   if (it != active_downloads_.end()) {
@@ skipping 134 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* item = GetDownloadItem(download_id);
   if (!item)
     return;
 
   if (item->safety_state() == DownloadItem::SAFE) {
     DCHECK_EQ(0, uniquifier) << "We should not uniquify SAFE downloads twice";
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(
-          file_manager_, &DownloadFileManager::CompleteDownload, download_id));
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, NewRunnableMethod(
+      file_manager_,
+      &DownloadFileManager::CompleteDownload,
+      item->global_id()));
 
   if (uniquifier)
     item->set_path_uniquifier(uniquifier);
 
   item->OnDownloadRenamedToFinalName(full_path);
   delegate_->UpdatePathForItemInPersistentStore(item, full_path);
 }
 
 void DownloadManager::CancelDownload(int32 download_id) {
   DownloadItem* download = GetActiveDownload(download_id);
@@ skipping 509 matching lines @@
     DCHECK(ContainsKey(save_page_downloads_, download->id()));
     save_page_downloads_.erase(download->id());
 
     if (download->IsComplete())
       NotificationService::current()->Notify(
           content::NOTIFICATION_SAVE_PACKAGE_SUCCESSFULLY_FINISHED,
           Source<DownloadManager>(this),
           Details<DownloadItem>(download));
   }
 }