Split DownloadItem into an ABC, an Impl, and a Mock.

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 "build/build_config.h"
 #include "content/browser/browser_context.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_id_factory.h"
-#include "content/browser/download/download_item.h"
+#include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_persistent_store_info.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/download_status_updater.h"
 #include "content/browser/download/interrupt_reasons.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 87 matching lines @@
   // Go through all downloads in downloads_.  Dangerous ones we need to
   // remove on disk, and in progress ones we need to cancel.
   for (DownloadSet::iterator it = downloads_.begin(); it != downloads_.end();) {
     DownloadItem* download = *it;
 
     // Save iterator from potential erases in this set done by called code.
     // Iterators after an erasure point are still valid for lists and
     // associative containers such as sets.
     it++;
 
-    if (download->safety_state() == DownloadItem::DANGEROUS &&
+    if (download->GetSafetyState() == DownloadItem::DANGEROUS &&
         download->IsPartialDownload()) {
       // The user hasn't accepted it, so we need to remove it
       // from the disk.  This may or may not result in it being
       // removed from the DownloadManager queues and deleted
       // (specifically, DownloadManager::RemoveDownload only
       // removes and deletes it if it's known to the history service)
       // so the only thing we know after calling this function is that
       // the download was deleted if-and-only-if it was removed
       // from all queues.
       download->Delete(DownloadItem::DELETE_DUE_TO_BROWSER_SHUTDOWN);
@@ skipping 24 matching lines @@
 
   shutdown_needed_ = false;
 }
 
 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)
+    if (it->second->IsTemporary() &&
+        it->second->GetFullPath().DirName() == dir_path)
       result->push_back(it->second);
   }
 }
 
 void DownloadManager::GetAllDownloads(
     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() &&
-        (dir_path.empty() || it->second->full_path().DirName() == dir_path))
+    if (!it->second->IsTemporary() &&
+        (dir_path.empty() || it->second->GetFullPath().DirName() == dir_path))
       result->push_back(it->second);
   }
 }
 
 void DownloadManager::SearchDownloads(const string16& query,
                                       DownloadVector* result) {
   string16 query_lower(base::i18n::ToLower(query));
 
   for (DownloadMap::iterator it = history_downloads_.begin();
        it != history_downloads_.end(); ++it) {
     DownloadItem* download_item = it->second;
 
-    if (download_item->is_temporary())
+    if (download_item->IsTemporary())
       continue;
 
     // Display Incognito downloads only in Incognito window, and vice versa.
     // The Incognito Downloads page will get the list of non-Incognito downloads
     // from its parent profile.
-    if (browser_context_->IsOffTheRecord() != download_item->is_otr())
+    if (browser_context_->IsOffTheRecord() != download_item->IsOtr())
       continue;
 
     if (download_item->MatchesQuery(query_lower))
       result->push_back(download_item);
   }
 }
 
 // Query the history service for information about all persisted downloads.
 bool DownloadManager::Init(content::BrowserContext* browser_context) {
   DCHECK(browser_context);
@@ skipping 27 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   for (DownloadMap::iterator it = history_downloads_.begin();
        it != history_downloads_.end(); ++it) {
     CheckForFileRemoval(it->second);
   }
 }
 
 void DownloadManager::CheckForFileRemoval(DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsComplete() &&
-      !download_item->file_externally_removed()) {
+      !download_item->GetFileExternallyRemoved()) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&DownloadManager::CheckForFileRemovalOnFileThread,
-                   this, download_item->db_handle(),
+                   this, download_item->GetDbHandle(),
                    download_item->GetTargetFilePath()));
   }
 }
 
 void DownloadManager::CheckForFileRemovalOnFileThread(
     int64 db_handle, const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::PathExists(path)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
@@ skipping 14 matching lines @@
     int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
   if (!download)
     return;
 
   VLOG(20) << __FUNCTION__ << "()"
            << " download = " << download->DebugString(true);
 
-  FilePath suggested_path = download->suggested_path();
+  FilePath suggested_path = download->GetSuggestedPath();
 
-  if (download->prompt_user_for_save_location()) {
+  if (download->PromptUserForSaveLocation()) {
     // We must ask the user for the place to put the download.
     TabContents* contents = download->GetTabContents();
 
     // |id_ptr| will be deleted in either FileSelected() or
     // FileSelectionCancelled().
     int32* id_ptr = new int32;
     *id_ptr = download_id;
 
     delegate_->ChooseDownloadPath(
         contents, suggested_path, reinterpret_cast<void*>(id_ptr));
 
     FOR_EACH_OBSERVER(Observer, observers_,
                       SelectFileDialogDisplayed(download_id));
   } else {
     // No prompting for download, just continue with the suggested name.
     ContinueDownloadWithPath(download, suggested_path);
   }
 }
 
 void DownloadManager::CreateDownloadItem(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DownloadItem* download = new DownloadItem(
+  DownloadItem* download = new DownloadItemImpl(
       this, *info, new DownloadRequestHandle(request_handle),
       browser_context_->IsOffTheRecord());
   int32 download_id = info->download_id.local();
   DCHECK(!ContainsKey(in_progress_, download_id));
 
   // TODO(rdsmith): Remove after http://crbug.com/85408 resolved.
   CHECK(!ContainsKey(active_downloads_, download_id));
   downloads_.insert(download);
   active_downloads_[download_id] = download;
 }
 
 void DownloadManager::ContinueDownloadWithPath(DownloadItem* download,
                                                const FilePath& chosen_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
 
-  int32 download_id = download->id();
+  int32 download_id = download->GetId();
 
   // NOTE(ahendrickson) Eventually |active_downloads_| will replace
   // |in_progress_|, but we don't want to change the semantics yet.
   DCHECK(!ContainsKey(in_progress_, download_id));
   DCHECK(ContainsKey(downloads_, download));
   DCHECK(ContainsKey(active_downloads_, download_id));
 
   // Make sure the initial file name is set only once.
   download->OnPathDetermined(chosen_file);
 
   VLOG(20) << __FUNCTION__ << "()"
            << " download = " << download->DebugString(true);
 
   in_progress_[download_id] = download;
   UpdateDownloadProgress();  // Reflect entry into in_progress_.
 
   // Rename to intermediate name.
   FilePath download_path;
   if (!delegate_->OverrideIntermediatePath(download, &download_path))
-    download_path = download->full_path();
+    download_path = download->GetFullPath();
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFileManager::RenameInProgressDownloadFile,
-                 file_manager_, download->global_id(), download_path));
+                 file_manager_, download->GetGlobalId(), 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 21 matching lines @@
 
   DownloadItem* download = active_downloads_[download_id];
   download->OnAllDataSaved(size, hash);
   delegate_->OnResponseCompleted(download);
 
   MaybeCompleteDownload(download);
 }
 
 void DownloadManager::AssertQueueStateConsistent(DownloadItem* download) {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
-  if (download->state() == DownloadItem::REMOVING) {
+  if (download->GetState() == DownloadItem::REMOVING) {
     CHECK(!ContainsKey(downloads_, download));
-    CHECK(!ContainsKey(active_downloads_, download->id()));
-    CHECK(!ContainsKey(in_progress_, download->id()));
-    CHECK(!ContainsKey(history_downloads_, download->db_handle()));
+    CHECK(!ContainsKey(active_downloads_, download->GetId()));
+    CHECK(!ContainsKey(in_progress_, download->GetId()));
+    CHECK(!ContainsKey(history_downloads_, download->GetDbHandle()));
     return;
   }
 
   // Should be in downloads_ if we're not REMOVING.
   CHECK(ContainsKey(downloads_, download));
 
   // Check history_downloads_ consistency.
-  if (download->db_handle() != DownloadItem::kUninitializedHandle) {
-    CHECK(ContainsKey(history_downloads_, download->db_handle()));
+  if (download->GetDbHandle() != DownloadItem::kUninitializedHandle) {
+    CHECK(ContainsKey(history_downloads_, download->GetDbHandle()));
   } else {
     // TODO(rdsmith): Somewhat painful; make sure to disable in
     // release builds after resolution of http://crbug.com/85408.
     for (DownloadMap::iterator it = history_downloads_.begin();
          it != history_downloads_.end(); ++it) {
       CHECK(it->second != download);
     }
   }
 
-  int64 state = download->state();
+  int64 state = download->GetState();
   base::debug::Alias(&state);
-  if (ContainsKey(active_downloads_, download->id())) {
-    if (download->db_handle() != DownloadItem::kUninitializedHandle)
-      CHECK_EQ(DownloadItem::IN_PROGRESS, download->state());
-    if (DownloadItem::IN_PROGRESS != download->state())
-      CHECK_EQ(DownloadItem::kUninitializedHandle, download->db_handle());
+  if (ContainsKey(active_downloads_, download->GetId())) {
+    if (download->GetDbHandle() != DownloadItem::kUninitializedHandle)
+      CHECK_EQ(DownloadItem::IN_PROGRESS, download->GetState());
+    if (DownloadItem::IN_PROGRESS != download->GetState())
+      CHECK_EQ(DownloadItem::kUninitializedHandle, download->GetDbHandle());
   }
-  if (DownloadItem::IN_PROGRESS == download->state())
-    CHECK(ContainsKey(active_downloads_, download->id()));
+  if (DownloadItem::IN_PROGRESS == download->GetState())
+    CHECK(ContainsKey(active_downloads_, download->GetId()));
 }
 
 bool DownloadManager::IsDownloadReadyForCompletion(DownloadItem* download) {
   // If we don't have all the data, the download is not ready for
   // completion.
-  if (!download->all_data_saved())
+  if (!download->AllDataSaved())
     return false;
 
   // If the download is dangerous, but not yet validated, it's not ready for
   // completion.
-  if (download->safety_state() == DownloadItem::DANGEROUS)
+  if (download->GetSafetyState() == DownloadItem::DANGEROUS)
     return false;
 
   // If the download isn't active (e.g. has been cancelled) it's not
   // ready for completion.
-  if (active_downloads_.count(download->id()) == 0)
+  if (active_downloads_.count(download->GetId()) == 0)
     return false;
 
   // If the download hasn't been inserted into the history system
   // (which occurs strictly after file name determination, intermediate
   // file rename, and UI display) then it's not ready for completion.
-  if (download->db_handle() == DownloadItem::kUninitializedHandle)
+  if (download->GetDbHandle() == DownloadItem::kUninitializedHandle)
     return false;
 
   return true;
 }
 
 void DownloadManager::MaybeCompleteDownload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(20) << __FUNCTION__ << "()" << " download = "
            << download->DebugString(false);
 
   if (!IsDownloadReadyForCompletion(download))
     return;
 
   // TODO(rdsmith): DCHECK that we only pass through this point
   // once per download.  The natural way to do this is by a state
   // transition on the DownloadItem.
 
   // Confirm we're in the proper set of states to be here;
   // in in_progress_, have all data, have a history handle, (validated or safe).
-  DCHECK_NE(DownloadItem::DANGEROUS, download->safety_state());
-  DCHECK_EQ(1u, in_progress_.count(download->id()));
-  DCHECK(download->all_data_saved());
-  DCHECK(download->db_handle() != DownloadItem::kUninitializedHandle);
-  DCHECK_EQ(1u, history_downloads_.count(download->db_handle()));
+  DCHECK_NE(DownloadItem::DANGEROUS, download->GetSafetyState());
+  DCHECK_EQ(1u, in_progress_.count(download->GetId()));
+  DCHECK(download->AllDataSaved());
+  DCHECK(download->GetDbHandle() != DownloadItem::kUninitializedHandle);
+  DCHECK_EQ(1u, history_downloads_.count(download->GetDbHandle()));
 
   // Give the delegate a chance to override.
   if (!delegate_->ShouldCompleteDownload(download))
     return;
 
   VLOG(20) << __FUNCTION__ << "()" << " executing: download = "
            << download->DebugString(false);
 
   // Remove the id from in_progress
-  in_progress_.erase(download->id());
+  in_progress_.erase(download->GetId());
   UpdateDownloadProgress();  // Reflect removal from in_progress_.
 
   delegate_->UpdateItemInPersistentStore(download);
 
   // Finish the download.
   download->OnDownloadCompleting(file_manager_);
 }
 
 void DownloadManager::DownloadCompleted(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* download = GetDownloadItem(download_id);
   DCHECK(download);
   delegate_->UpdateItemInPersistentStore(download);
   active_downloads_.erase(download_id);
   AssertQueueStateConsistent(download);
 }
 
 void DownloadManager::OnDownloadRenamedToFinalName(int download_id,
                                                    const FilePath& full_path,
                                                    int uniquifier) {
   VLOG(20) << __FUNCTION__ << "()" << " download_id = " << download_id
            << " full_path = \"" << full_path.value() << "\""
            << " uniquifier = " << uniquifier;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* item = GetDownloadItem(download_id);
   if (!item)
     return;
 
-  if (item->safety_state() == DownloadItem::SAFE) {
+  if (item->GetSafetyState() == DownloadItem::SAFE) {
     DCHECK_EQ(0, uniquifier) << "We should not uniquify SAFE downloads twice";
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFileManager::CompleteDownload,
-                 file_manager_, item->global_id()));
+                 file_manager_, item->GetGlobalId()));
 
   if (uniquifier)
-    item->set_path_uniquifier(uniquifier);
+    item->SetPathUniquifier(uniquifier);
 
   item->OnDownloadRenamedToFinalName(full_path);
   delegate_->UpdatePathForItemInPersistentStore(item, full_path);
 }
 
 void DownloadManager::CancelDownload(int32 download_id) {
   DownloadItem* download = GetActiveDownload(download_id);
   // A cancel at the right time could remove the download from the
   // |active_downloads_| map before we get here.
   if (!download)
@@ skipping 21 matching lines @@
                                             int64 size,
                                             InterruptReason reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownload(download_id);
   if (!download)
     return;
 
   VLOG(20) << __FUNCTION__ << "()"
            << " reason " << InterruptReasonDebugString(reason)
-           << " at offset " << download->received_bytes()
+           << " at offset " << download->GetReceivedBytes()
            << " size = " << size
            << " download = " << download->DebugString(true);
 
   RemoveFromActiveList(download);
   download->Interrupted(size, reason);
   download->OffThreadCancel(file_manager_);
 }
 
 DownloadItem* DownloadManager::GetActiveDownload(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadMap::iterator it = active_downloads_.find(download_id);
   if (it == active_downloads_.end())
     return NULL;
 
   DownloadItem* download = it->second;
 
   DCHECK(download);
-  DCHECK_EQ(download_id, download->id());
+  DCHECK_EQ(download_id, download->GetId());
 
   return download;
 }
 
 void DownloadManager::RemoveFromActiveList(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
-  if (download->db_handle() != DownloadItem::kUninitializedHandle) {
-    in_progress_.erase(download->id());
-    active_downloads_.erase(download->id());
+  if (download->GetDbHandle() != DownloadItem::kUninitializedHandle) {
+    in_progress_.erase(download->GetId());
+    active_downloads_.erase(download->GetId());
     UpdateDownloadProgress();  // Reflect removal from in_progress_.
     delegate_->UpdateItemInPersistentStore(download);
   }
 }
 
 void DownloadManager::SetDownloadManagerDelegate(
     content::DownloadManagerDelegate* delegate) {
   delegate_ = delegate;
 }
 
 void DownloadManager::UpdateDownloadProgress() {
   delegate_->DownloadProgressUpdated();
 }
 
 int DownloadManager::RemoveDownloadItems(
     const DownloadVector& pending_deletes) {
   if (pending_deletes.empty())
     return 0;
 
   // Delete from internal maps.
   for (DownloadVector::const_iterator it = pending_deletes.begin();
       it != pending_deletes.end();
       ++it) {
     DownloadItem* download = *it;
     DCHECK(download);
-    history_downloads_.erase(download->db_handle());
-    save_page_downloads_.erase(download->id());
+    history_downloads_.erase(download->GetDbHandle());
+    save_page_downloads_.erase(download->GetId());
     downloads_.erase(download);
   }
 
   // Tell observers to refresh their views.
   NotifyModelChanged();
 
   // Delete the download items themselves.
   const int num_deleted = static_cast<int>(pending_deletes.size());
   STLDeleteContainerPointers(pending_deletes.begin(), pending_deletes.end());
   return num_deleted;
@@ skipping 17 matching lines @@
                                             const base::Time remove_end) {
   delegate_->RemoveItemsFromPersistentStoreBetween(remove_begin, remove_end);
 
   // All downloads visible to the user will be in the history,
   // so scan that map.
   DownloadVector pending_deletes;
   for (DownloadMap::const_iterator it = history_downloads_.begin();
       it != history_downloads_.end();
       ++it) {
     DownloadItem* download = it->second;
-    if (download->start_time() >= remove_begin &&
-        (remove_end.is_null() || download->start_time() < remove_end) &&
+    if (download->GetStartTime() >= remove_begin &&
+        (remove_end.is_null() || download->GetStartTime() < remove_end) &&
         (download->IsComplete() || download->IsCancelled())) {
       AssertQueueStateConsistent(download);
       pending_deletes.push_back(download);
     }
   }
   return RemoveDownloadItems(pending_deletes);
 }
 
 int DownloadManager::RemoveDownloads(const base::Time remove_begin) {
   return RemoveDownloadsBetween(remove_begin, base::Time());
@@ skipping 41 matching lines @@
   observer->ModelChanged();
 }
 
 void DownloadManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool DownloadManager::IsDownloadProgressKnown() const {
   for (DownloadMap::const_iterator i = in_progress_.begin();
        i != in_progress_.end(); ++i) {
-    if (i->second->total_bytes() <= 0)
+    if (i->second->GetTotalBytes() <= 0)
       return false;
   }
 
   return true;
 }
 
 int64 DownloadManager::GetInProgressDownloadCount() const {
   return in_progress_.size();
 }
 
 int64 DownloadManager::GetReceivedDownloadBytes() const {
   DCHECK(IsDownloadProgressKnown());
   int64 received_bytes = 0;
   for (DownloadMap::const_iterator i = in_progress_.begin();
        i != in_progress_.end(); ++i) {
-    received_bytes += i->second->received_bytes();
+    received_bytes += i->second->GetReceivedBytes();
   }
   return received_bytes;
 }
 
 int64 DownloadManager::GetTotalDownloadBytes() const {
   DCHECK(IsDownloadProgressKnown());
   int64 total_bytes = 0;
   for (DownloadMap::const_iterator i = in_progress_.begin();
        i != in_progress_.end(); ++i) {
-    total_bytes += i->second->total_bytes();
+    total_bytes += i->second->GetTotalBytes();
   }
   return total_bytes;
 }
 
 void DownloadManager::FileSelected(const FilePath& path, void* params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   int32* id_ptr = reinterpret_cast<int32*>(params);
   DCHECK(id_ptr != NULL);
   int32 download_id = *id_ptr;
   delete id_ptr;
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
   if (!download)
     return;
   VLOG(20) << __FUNCTION__ << "()" << " path = \"" << path.value() << "\""
             << " download = " << download->DebugString(true);
 
-  if (download->prompt_user_for_save_location())
+  if (download->PromptUserForSaveLocation())
     last_download_path_ = path.DirName();
 
   // Make sure the initial file name is set only once.
   ContinueDownloadWithPath(download, path);
 }
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 21 matching lines @@
 
 // The history service has retrieved all download entries. 'entries' contains
 // 'DownloadPersistentStoreInfo's in sorted order (by ascending start_time).
 void DownloadManager::OnPersistentStoreQueryComplete(
     std::vector<DownloadPersistentStoreInfo>* entries) {
   // TODO(rdsmith): Remove this and related logic when
   // http://crbug.com/85408 is fixed.
   largest_db_handle_in_history_ = 0;
 
   for (size_t i = 0; i < entries->size(); ++i) {
-    DownloadItem* download = new DownloadItem(this, entries->at(i));
+    DownloadItem* download = new DownloadItemImpl(this, entries->at(i));
     // TODO(rdsmith): Remove after http://crbug.com/85408 resolved.
-    CHECK(!ContainsKey(history_downloads_, download->db_handle()));
+    CHECK(!ContainsKey(history_downloads_, download->GetDbHandle()));
     downloads_.insert(download);
-    history_downloads_[download->db_handle()] = download;
+    history_downloads_[download->GetDbHandle()] = download;
     VLOG(20) << __FUNCTION__ << "()" << i << ">"
              << " download = " << download->DebugString(true);
 
-    if (download->db_handle() > largest_db_handle_in_history_)
-      largest_db_handle_in_history_ = download->db_handle();
+    if (download->GetDbHandle() > largest_db_handle_in_history_)
+      largest_db_handle_in_history_ = download->GetDbHandle();
   }
   NotifyModelChanged();
   CheckForHistoryFilesRemoval();
 }
 
 void DownloadManager::AddDownloadItemToHistory(DownloadItem* download,
                                                int64 db_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(rdsmith): Convert to DCHECK() when http://crbug.com/85408
   // is fixed.
   CHECK_NE(DownloadItem::kUninitializedHandle, db_handle);
 
   download_stats::RecordHistorySize(history_downloads_.size());
 
-  DCHECK(download->db_handle() == DownloadItem::kUninitializedHandle);
-  download->set_db_handle(db_handle);
+  DCHECK(download->GetDbHandle() == DownloadItem::kUninitializedHandle);
+  download->SetDbHandle(db_handle);
 
   // TODO(rdsmith): Convert to DCHECK() when http://crbug.com/85408
   // is fixed.
-  CHECK(!ContainsKey(history_downloads_, download->db_handle()));
-  history_downloads_[download->db_handle()] = download;
+  CHECK(!ContainsKey(history_downloads_, download->GetDbHandle()));
+  history_downloads_[download->GetDbHandle()] = download;
 
   // Show in the appropriate browser UI.
   // This includes buttons to save or cancel, for a dangerous download.
   ShowDownloadInBrowser(download);
 
   // Inform interested objects about the new download.
   NotifyModelChanged();
 }
 
 
@@ skipping 19 matching lines @@
 
   VLOG(20) << __FUNCTION__ << "()" << " db_handle = " << db_handle
            << " download_id = " << download_id
            << " download = " << download->DebugString(true);
 
   // TODO(rdsmith): Remove after http://crbug.com/85408 resolved.
   int64 largest_handle = largest_db_handle_in_history_;
   base::debug::Alias(&largest_handle);
   int32 matching_item_download_id
       = (ContainsKey(history_downloads_, db_handle) ?
-         history_downloads_[db_handle]->id() : 0);
+         history_downloads_[db_handle]->GetId() : 0);
   base::debug::Alias(&matching_item_download_id);
 
   CHECK(!ContainsKey(history_downloads_, db_handle));
 
   AddDownloadItemToHistory(download, db_handle);
 
   // If the download is still in progress, try to complete it.
   //
   // Otherwise, download has been cancelled or interrupted before we've
   // received the DB handle.  We post one final message to the history
@@ skipping 36 matching lines @@
 void DownloadManager::NotifyModelChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, ModelChanged());
 }
 
 DownloadItem* DownloadManager::GetDownloadItem(int download_id) {
   // The |history_downloads_| map is indexed by the download's db_handle,
   // not its id, so we have to iterate.
   for (DownloadMap::iterator it = history_downloads_.begin();
        it != history_downloads_.end(); ++it) {
     DownloadItem* item = it->second;
-    if (item->id() == download_id)
+    if (item->GetId() == download_id)
       return item;
   }
   return NULL;
 }
 
 DownloadItem* DownloadManager::GetActiveDownloadItem(int download_id) {
   DCHECK(ContainsKey(active_downloads_, download_id));
   DownloadItem* download = active_downloads_[download_id];
   DCHECK(download != NULL);
   return download;
@@ skipping 38 matching lines @@
   std::insert_iterator<DownloadSet>
       insert_remainder(remainder, remainder.begin());
   std::set_difference(downloads_.begin(), downloads_.end(),
                       downloads_union.begin(), downloads_union.end(),
                       insert_remainder);
   DCHECK(remainder.empty());
 #endif
 }
 
 void DownloadManager::SavePageDownloadStarted(DownloadItem* download) {
-  DCHECK(!ContainsKey(save_page_downloads_, download->id()));
+  DCHECK(!ContainsKey(save_page_downloads_, download->GetId()));
   downloads_.insert(download);
-  save_page_downloads_[download->id()] = download;
+  save_page_downloads_[download->GetId()] = download;
 
   // Add this entry to the history service.
   // Additionally, the UI is notified in the callback.
   delegate_->AddItemToPersistentStore(download);
 }
 
 // SavePackage will call SavePageDownloadFinished upon completion/cancellation.
 // The history callback will call OnSavePageItemAddedToPersistentStore.
 // If the download finishes before the history callback,
 // OnSavePageItemAddedToPersistentStore calls SavePageDownloadFinished, ensuring
@@ skipping 29 matching lines @@
   CHECK(!ContainsKey(history_downloads_, db_handle));
 
   AddDownloadItemToHistory(download, db_handle);
 
   // Finalize this download if it finished before the history callback.
   if (!download->IsInProgress())
     SavePageDownloadFinished(download);
 }
 
 void DownloadManager::SavePageDownloadFinished(DownloadItem* download) {
-  if (download->db_handle() != DownloadItem::kUninitializedHandle) {
+  if (download->GetDbHandle() != DownloadItem::kUninitializedHandle) {
     delegate_->UpdateItemInPersistentStore(download);
-    DCHECK(ContainsKey(save_page_downloads_, download->id()));
-    save_page_downloads_.erase(download->id());
+    DCHECK(ContainsKey(save_page_downloads_, download->GetId()));
+    save_page_downloads_.erase(download->GetId());
 
     if (download->IsComplete())
       content::NotificationService::current()->Notify(
           content::NOTIFICATION_SAVE_PACKAGE_SUCCESSFULLY_FINISHED,
           content::Source<DownloadManager>(this),
           content::Details<DownloadItem>(download));
   }
 }
 
 void DownloadManager::MarkDownloadOpened(DownloadItem* download) {
   delegate_->UpdateItemInPersistentStore(download);
   int num_unopened = 0;
   for (DownloadMap::iterator it = history_downloads_.begin();
        it != history_downloads_.end(); ++it) {
-    if (it->second->IsComplete() && !it->second->opened())
+    if (it->second->IsComplete() && !it->second->GetOpened())
       ++num_unopened;
   }
   download_stats::RecordOpensOutstanding(num_unopened);
 }