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 34 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 12 matching lines @@
   // thread.
   DownloadItem* download =
       download_manager_->GetActiveDownloadItem(download_id);
   if (!download)
     return false;
 
 #if defined(ENABLE_SAFE_BROWSING)
   // Create a client to verify download URL with safebrowsing.
   // It deletes itself after the callback.
   scoped_refptr<DownloadSBClient> sb_client = new DownloadSBClient(
-      download_id, download->url_chain(), download->referrer_url(),
+      download_id, download->GetUrlChain(), download->GetReferrerUrl(),
           profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled));
   sb_client->CheckDownloadUrl(
       base::Bind(&ChromeDownloadManagerDelegate::CheckDownloadUrlDone,
                  base::Unretained(this)));
 #else
   CheckDownloadUrlDone(download_id, false);
 #endif
   return false;
 }
 
@@ skipping 11 matching lines @@
     FilePath* intermediate_path) {
   if (item->IsDangerous()) {
     // The download is not 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;
 }
@@ skipping 21 matching lines @@
     // Begin the safe browsing download protection check.
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
     if (sb_service && sb_service->download_protection_service() &&
         profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) {
       using safe_browsing::DownloadProtectionService;
       sb_service->download_protection_service()->CheckClientDownload(
           DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
           base::Bind(
               &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
-              this, item->id()));
+              this, item->GetId()));
       // For now, we won't delay the download for this.
     }
 #else
     // Assume safe.
 #endif
 
     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) &&
       g_browser_process->safe_browsing_service()->DownloadBinHashNeeded();
 #else
   return false;
 #endif
 }
 
 void ChromeDownloadManagerDelegate::OnResponseCompleted(DownloadItem* item) {
 #if defined(ENABLE_SAFE_BROWSING)
   // When hash is not available, it means either it is not calculated
   // or there is error while it is calculated. We will skip the download hash
   // check in that case.
-  if (item->hash().empty())
+  if (item->GetHash().empty())
     return;
 
   scoped_refptr<DownloadSBClient> sb_client =
-      new DownloadSBClient(item->id(),
-                           item->url_chain(),
-                           item->referrer_url(),
+      new DownloadSBClient(item->GetId(),
+                           item->GetUrlChain(),
+                           item->GetReferrerUrl(),
                            profile_->GetPrefs()->GetBoolean(
                                prefs::kSafeBrowsingEnabled));
   sb_client->CheckDownloadHash(
-      item->hash(),
+      item->GetHash(),
       base::Bind(&ChromeDownloadManagerDelegate::CheckDownloadHashDone,
                  base::Unretained(this)));
 #endif
 }
 
 void ChromeDownloadManagerDelegate::AddItemToPersistentStore(
     DownloadItem* item) {
   download_history_->AddEntry(item,
       base::Bind(&ChromeDownloadManagerDelegate::OnItemAddedToPersistentStore,
                  base::Unretained(this)));
@@ skipping 82 matching lines @@
 
   DownloadItem* download =
       download_manager_->GetActiveDownloadItem(download_id);
   if (!download)
     return;
 
   if (is_dangerous_url)
     download->MarkUrlDangerous();
 
   download_history_->CheckVisitedReferrerBefore(
-      download_id, download->referrer_url(),
+      download_id, download->GetReferrerUrl(),
       base::Bind(&ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone,
                  base::Unretained(this)));
 }
 
 // content::NotificationObserver implementation.
 void ChromeDownloadManagerDelegate::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_CRX_INSTALLER_DONE);
@@ skipping 16 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 30 matching lines @@
         IsDangerousFile(*download, state, visited_referrer_before);
   }
 
   // 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.
@@ skipping 20 matching lines @@
 // TODO(noelutz): This function currently works as a callback place holder.
 // Once we decide the hash check is reliable, we could move the
 // MaybeCompleteDownload in OnAllDataSaved to this function.
 void ChromeDownloadManagerDelegate::CheckDownloadHashDone(
     int32 download_id,
     bool is_dangerous_hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "CheckDownloadHashDone, download_id: " << download_id
            << " is dangerous_hash: " << is_dangerous_hash;
 }