sql::MetaTable.next_download_id, DownloadManager::GetNextId()

content/browser/download/download_manager.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.
 //
 // The DownloadManager object manages the process of downloading, including
 // updates to the history system and providing the information for displaying
 // the downloads view in the Destinations tab. There is one DownloadManager per
 // active browser context in Chrome.
 //
 // Download observers:
@@ skipping 16 matching lines @@
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.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/synchronization/lock.h"
 #include "base/time.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/download/download_item.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_status_updater_delegate.h"
 
 class DownloadFileManager;
 class DownloadManagerDelegate;
 class DownloadStatusUpdater;
 class GURL;
@@ skipping 45 matching lines @@
   void GetTemporaryDownloads(const FilePath& dir_path, DownloadVector* result);
 
   // Return all non-temporary downloads in the specified directory that are
   // are in progress or have completed.
   void GetAllDownloads(const FilePath& dir_path, DownloadVector* result);
 
   // Returns all non-temporary downloads matching |query|. Empty query matches
   // everything.
   void SearchDownloads(const string16& query, DownloadVector* result);
 
+  // Returns the next download id in a DownloadId and increments the counter.
+  // May be called on any thread. The incremented counter is not persisted, but
+  // the base counter for this accessor is initialized from the largest id
+  // actually saved to the download history database.
+  DownloadId GetNextId();
+
+  // Instead of passing a DownloadManager* between threads and hoping users only
+  // call GetNextId(), you can pass this thunk around instead. Pass the thunk
+  // around by const ref and store it by copy per the base::Callback interface.
+  // The thunk may be copied, including between threads.  If you change
+  // GetNextIdThunkType from base::Callback, then you should think about how
+  // you're changing the ref-count of DownloadManager. Use it like:
+  //   const DownloadManager::GetNextIdThunkType& next_id_thunk =
+  //       download_manager->GetNextIdThunk();
+  //   id = next_id_thunk.Run();
+  typedef base::Callback<DownloadId(void)> GetNextIdThunkType;
+  GetNextIdThunkType GetNextIdThunk();
+
   // Returns true if initialized properly.
   bool Init(content::BrowserContext* browser_context);
 
   // Notifications sent from the download thread to the UI thread
   void StartDownload(int32 id);
   void UpdateDownload(int32 download_id, int64 size);
   // |hash| is sha256 hash for the downloaded file. It is empty when the hash
   // is not available.
   void OnResponseCompleted(int32 download_id, int64 size, int os_error,
                            const std::string& hash);
@@ skipping 60 matching lines @@
                          const std::string& referrer_encoding,
                          const DownloadSaveInfo& save_info,
                          TabContents* tab_contents);
 
   // Allow objects to observe the download creation process.
   void AddObserver(Observer* observer);
 
   // Remove a download observer from ourself.
   void RemoveObserver(Observer* observer);
 
+  // Called by the embedder after creating the download manager to inform it of
+  // the next available download id.
+  // TODO(benjhayden): Separate this functionality out into a separate object.
+  void OnPersistentStoreGetNextId(int next_id);
+
   // Called by the embedder, after creating the download manager, to let it know
   // about downloads from previous runs of the browser.
   void OnPersistentStoreQueryComplete(
       std::vector<DownloadPersistentStoreInfo>* entries);
 
   // Called by the embedder, in response to
   // DownloadManagerDelegate::AddItemToPersistentStore.
   void OnItemAddedToPersistentStore(int32 download_id, int64 db_handle);
 
   // Display a new download in the appropriate browser UI.
@@ skipping 162 matching lines @@
 
   // 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.
   content::BrowserContext* browser_context_;
 
+  base::Lock next_id_lock_;
+  int next_id_;
+
   // Non-owning pointer for handling file writing on the download_thread_.
   DownloadFileManager* file_manager_;
 
   // Non-owning pointer for updating the download status.
   base::WeakPtr<DownloadStatusUpdater> status_updater_;
 
   // The user's last choice for download directory. This is only used when the
   // user wants us to prompt for a save location for each download.
   FilePath last_download_path_;
 
   // Allows an embedder to control behavior. Guaranteed to outlive this object.
   DownloadManagerDelegate* delegate_;
 
   // TODO(rdsmith): Remove when http://crbug.com/84508 is fixed.
   // For debugging only.
   int64 largest_db_handle_in_history_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManager);
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_MANAGER_H_