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

chrome/browser/download/chrome_download_manager_delegate.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 "chrome/browser/download/chrome_download_manager_delegate.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 35 matching lines @@
 ChromeDownloadManagerDelegate::ChromeDownloadManagerDelegate(Profile* profile)
     : profile_(profile),
       download_prefs_(new DownloadPrefs(profile->GetPrefs())) {
 }
 
 ChromeDownloadManagerDelegate::~ChromeDownloadManagerDelegate() {
 }
 
 bool ChromeDownloadManagerDelegate::IsExtensionDownload(
     const DownloadItem* item) {
-  if (item->prompt_user_for_save_location())
+  if (item->PromptUserForSaveLocation())
     return false;
 
-  return (item->mime_type() == Extension::kMimeType) ||
-      UserScript::IsURLUserScript(item->GetURL(), item->mime_type());
+  return (item->GetMimeType() == Extension::kMimeType) ||
+      UserScript::IsURLUserScript(item->GetURL(), item->GetMimeType());
 }
 
 void ChromeDownloadManagerDelegate::SetDownloadManager(DownloadManager* dm) {
   download_manager_ = dm;
   download_history_.reset(new DownloadHistory(profile_));
   download_history_->Load(
       base::Bind(&DownloadManager::OnPersistentStoreQueryComplete,
                  base::Unretained(dm)));
 }
 
@@ skipping 18 matching lines @@
 #if defined(ENABLE_SAFE_BROWSING)
   DownloadProtectionService* service = GetDownloadProtectionService();
   if (service) {
     VLOG(2) << __FUNCTION__ << "() Start SB URL check for download = "
             << download->DebugString(false);
     service->CheckDownloadUrl(
         DownloadProtectionService::DownloadInfo::FromDownloadItem(*download),
         base::Bind(
             &ChromeDownloadManagerDelegate::CheckDownloadUrlDone,
             this,
-            download->id()));
+            download->GetId()));
     return false;
   }
 #endif
   CheckDownloadUrlDone(download_id, DownloadProtectionService::SAFE);
   return false;
 }
 
 void ChromeDownloadManagerDelegate::ChooseDownloadPath(
     TabContents* tab_contents,
     const FilePath& suggested_path,
     void* data) {
   // Deletes itself.
   new DownloadFilePicker(
       download_manager_, tab_contents, suggested_path, data);
 }
 
 bool ChromeDownloadManagerDelegate::OverrideIntermediatePath(
     DownloadItem* item,
     FilePath* intermediate_path) {
   if (item->GetDangerType() != DownloadStateInfo::NOT_DANGEROUS) {
     // The download might not be safe.  It's name is already set to an
     // intermediate name, so no need to override.
     return false;
   }
 
   // The download is a safe download.  We need to rename it to its intermediate
   // '.crdownload' path.  The final name after user confirmation will be set
   // from DownloadItem::OnDownloadCompleting.
-  *intermediate_path = download_util::GetCrDownloadPath(item->full_path());
+  *intermediate_path = download_util::GetCrDownloadPath(item->GetFullPath());
   return true;
 }
 
 TabContents* ChromeDownloadManagerDelegate::
     GetAlternativeTabContentsToNotifyForDownload() {
   // Start the download in the last active browser. This is not ideal but better
   // than fully hiding the download from the user.
   Browser* last_active = BrowserList::GetLastActiveWithProfile(profile_);
   return last_active ? last_active->GetSelectedTabContents() : NULL;
 }
 
 
 bool ChromeDownloadManagerDelegate::ShouldOpenFileBasedOnExtension(
     const FilePath& path) {
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return false;
   if (Extension::IsExtension(path))
     return false;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   return download_prefs_->IsAutoOpenEnabledForExtension(extension);
 }
 
 bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(DownloadItem* item) {
 #if defined(ENABLE_SAFE_BROWSING)
   // See if there is already a pending SafeBrowsing check for that download.
-  SafeBrowsingStateMap::iterator it = safe_browsing_state_.find(item->id());
+  SafeBrowsingStateMap::iterator it = safe_browsing_state_.find(item->GetId());
   if (it != safe_browsing_state_.end()) {
     SafeBrowsingState state = it->second;
     if (!state.pending) {
       safe_browsing_state_.erase(it);
     }
     return !state.pending;
   }
   // Begin the safe browsing download protection check.
   DownloadProtectionService* service = GetDownloadProtectionService();
   if (service) {
     VLOG(2) << __FUNCTION__ << "() Start SB download check for download = "
             << item->DebugString(false);
     service->CheckClientDownload(
         DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
         base::Bind(
             &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
             this,
-            item->id()));
+            item->GetId()));
     SafeBrowsingState state;
     state.pending = true;
     state.verdict = DownloadProtectionService::SAFE;
-    safe_browsing_state_[item->id()] = state;
+    safe_browsing_state_[item->GetId()] = state;
     return false;
   }
 #endif
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenDownload(DownloadItem* item) {
   if (!IsExtensionDownload(item)) {
     return true;
   }
 
   scoped_refptr<CrxInstaller> crx_installer =
       download_crx_util::OpenChromeExtension(profile_, *item);
 
   // CRX_INSTALLER_DONE will fire when the install completes.  Observe()
   // will call DelayedDownloadOpened() on this item.  If this DownloadItem is
   // not around when CRX_INSTALLER_DONE fires, Complete() will not be called.
   registrar_.Add(this,
                  chrome::NOTIFICATION_CRX_INSTALLER_DONE,
                  content::Source<CrxInstaller>(crx_installer.get()));
 
-  crx_installers_[crx_installer.get()] = item->id();
+  crx_installers_[crx_installer.get()] = item->GetId();
   // The status text and percent complete indicator will change now
   // that we are installing a CRX.  Update observers so that they pick
   // up the change.
   item->UpdateObservers();
   return false;
 }
 
 bool ChromeDownloadManagerDelegate::GenerateFileHash() {
 #if defined(ENABLE_SAFE_BROWSING)
   return profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled) &&
@@ skipping 104 matching lines @@
       download_manager_->GetActiveDownloadItem(download_id);
   if (!download)
     return;
 
   VLOG(2) << __FUNCTION__ << "() download = " << download->DebugString(false)
           << " verdict = " << result;
   if (result == DownloadProtectionService::DANGEROUS)
     download->MarkUrlDangerous();
 
   download_history_->CheckVisitedReferrerBefore(
-      download_id, download->referrer_url(),
+      download_id, download->GetReferrerUrl(),
       base::Bind(&ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone,
                  base::Unretained(this)));
 }
 
 void ChromeDownloadManagerDelegate::CheckClientDownloadDone(
     int32 download_id,
     DownloadProtectionService::DownloadCheckResult result) {
   DownloadItem* item = download_manager_->GetActiveDownloadItem(download_id);
   if (!item) {
     safe_browsing_state_.erase(download_id);  // Just in case.
     return;
   }
 
   VLOG(2) << __FUNCTION__ << "() download = " << item->DebugString(false)
           << " verdict = " << result;
   // We only mark the content as being dangerous if the download's safety state
   // has not been set to DANGEROUS yet.  We don't want to show two warnings.
   if (result == DownloadProtectionService::DANGEROUS &&
-      item->safety_state() == DownloadItem::SAFE)
+      item->GetSafetyState() == DownloadItem::SAFE)
     item->MarkContentDangerous();
 
-  SafeBrowsingStateMap::iterator it = safe_browsing_state_.find(item->id());
+  SafeBrowsingStateMap::iterator it = safe_browsing_state_.find(item->GetId());
   DCHECK(it != safe_browsing_state_.end() && it->second.pending);
   if (it != safe_browsing_state_.end()) {
     it->second.pending = false;
     it->second.verdict = result;
   }
   download_manager_->MaybeCompleteDownload(item);
 }
 
 // content::NotificationObserver implementation.
 void ChromeDownloadManagerDelegate::Observe(
@@ skipping 20 matching lines @@
     bool visited_referrer_before) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download =
       download_manager_->GetActiveDownloadItem(download_id);
   if (!download)
     return;
 
   // Check whether this download is for an extension install or not.
   // Allow extensions to be explicitly saved.
-  DownloadStateInfo state = download->state_info();
+  DownloadStateInfo state = download->GetStateInfo();
 
   if (state.force_file_name.empty()) {
     FilePath generated_name;
     download_util::GenerateFileNameFromRequest(*download,
                                                &generated_name);
 
     // Freeze the user's preference for showing a Save As dialog.  We're going
     // to bounce around a bunch of threads and we don't want to worry about race
     // conditions where the user changes this pref out from under us.
     if (download_prefs_->PromptForDownload()) {
@@ skipping 44 matching lines @@
   }
 #endif
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   // We can only access preferences on the UI thread, so check the download path
   // now and pass the value to the FILE thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ChromeDownloadManagerDelegate::CheckIfSuggestedPathExists,
-                 this, download->id(), state,
+                 this, download->GetId(), state,
                  download_prefs_->download_path()));
 }
 
 void ChromeDownloadManagerDelegate::CheckIfSuggestedPathExists(
     int32 download_id,
     DownloadStateInfo state,
     const FilePath& default_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Make sure the default download directory exists.
@@ skipping 97 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Anything loaded directly from the address bar is OK.
   if (state.transition_type & content::PAGE_TRANSITION_FROM_ADDRESS_BAR)
     return false;
 
   // Extensions that are not from the gallery are considered dangerous.
   if (IsExtensionDownload(&download)) {
     ExtensionService* service = profile_->GetExtensionService();
     if (!service || !service->IsDownloadFromGallery(download.GetURL(),
-                                                    download.referrer_url()))
+                                                    download.GetReferrerUrl()))
       return true;
   }
 
   // Anything the user has marked auto-open is OK if it's user-initiated.
   if (ShouldOpenFileBasedOnExtension(state.suggested_path) &&
       state.has_user_gesture)
     return false;
 
   // "Allow on user gesture" is OK when we have a user gesture and the hosting
   // page has been visited before today.
   download_util::DownloadDangerLevel danger_level =
       download_util::GetFileDangerLevel(state.suggested_path.BaseName());
   if (danger_level == download_util::AllowOnUserGesture)
     return !state.has_user_gesture || !visited_referrer_before;
 
   return danger_level == download_util::Dangerous;
 }
 
 void ChromeDownloadManagerDelegate::OnItemAddedToPersistentStore(
     int32 download_id, int64 db_handle) {
   // It's not immediately obvious, but HistoryBackend::CreateDownload() can
   // call this function with an invalid |db_handle|. For instance, this can
   // happen when the history database is offline. We cannot have multiple
   // DownloadItems with the same invalid db_handle, so we need to assign a
   // unique |db_handle| here.
   if (db_handle == DownloadItem::kUninitializedHandle)
     db_handle = download_history_->GetNextFakeDbHandle();
   download_manager_->OnItemAddedToPersistentStore(download_id, db_handle);
 }