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

chrome/browser/download/download_util.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.
 //
 // Download utility implementation
 
 #include "chrome/browser/download/download_util.h"
 
 #if defined(OS_WIN)
 #include <shobjidl.h>
@@ skipping 113 matching lines @@
   }
   return (download_path == desktop_dir);
 }
 
 void GenerateFileNameFromRequest(const DownloadItem& download_item,
                                  FilePath* generated_name) {
   std::string default_file_name(
       l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
 
   *generated_name = net::GenerateFileName(download_item.GetURL(),
-                                          download_item.content_disposition(),
-                                          download_item.referrer_charset(),
-                                          download_item.suggested_filename(),
-                                          download_item.mime_type(),
+                                          download_item.GetContentDisposition(),
+                                          download_item.GetReferrerCharset(),
+                                          download_item.GetSuggestedFilename(),
+                                          download_item.GetMimeType(),
                                           default_file_name);
 }
 
 // Download progress painting --------------------------------------------------
 
 // Common bitmaps used for download progress animations. We load them once the
 // first time we do a progress paint, then reuse them as they are always the
 // same.
 SkBitmap* g_foreground_16 = NULL;
 SkBitmap* g_background_16 = NULL;
@@ skipping 199 matching lines @@
   DCHECK(download);
 
   // Set up our OLE machinery
   ui::OSExchangeData data;
 
   if (icon) {
     drag_utils::CreateDragImageForFile(
         download->GetFileNameToReportUser(), *icon, &data);
   }
 
-  const FilePath full_path = download->full_path();
+  const FilePath full_path = download->GetFullPath();
   data.SetFilename(full_path);
 
-  std::string mime_type = download->mime_type();
+  std::string mime_type = download->GetMimeType();
   if (mime_type.empty())
     net::GetMimeTypeFromFile(full_path, &mime_type);
 
   // Add URL so that we can load supported files when dragged to TabContents.
   if (net::IsSupportedMimeType(mime_type)) {
     data.SetURL(net::FilePathToFileURL(full_path),
                 download->GetFileNameToReportUser().LossyDisplayName());
   }
 
 #if defined(USE_AURA)
@@ skipping 25 matching lines @@
                   gfx::Image* icon,
                   gfx::NativeView view) {
   DownloadItemDrag::BeginDrag(download, icon);
 }
 #endif  // USE_X11
 
 DictionaryValue* CreateDownloadItemValue(DownloadItem* download, int id) {
   DictionaryValue* file_value = new DictionaryValue();
 
   file_value->SetInteger("started",
-      static_cast<int>(download->start_time().ToTimeT()));
+      static_cast<int>(download->GetStartTime().ToTimeT()));
   file_value->SetString("since_string",
-      TimeFormat::RelativeDate(download->start_time(), NULL));
+      TimeFormat::RelativeDate(download->GetStartTime(), NULL));
   file_value->SetString("date_string",
-      base::TimeFormatShortDate(download->start_time()));
+      base::TimeFormatShortDate(download->GetStartTime()));
   file_value->SetInteger("id", id);
 
   FilePath download_path(download->GetTargetFilePath());
   file_value->Set("file_path", base::CreateFilePathValue(download_path));
   file_value->SetString("file_url",
                         net::FilePathToFileURL(download_path).spec());
 
   // Keep file names as LTR.
   string16 file_name = download->GetFileNameToReportUser().LossyDisplayName();
   file_name = base::i18n::GetDisplayStringInLTRDirectionality(file_name);
   file_value->SetString("file_name", file_name);
   file_value->SetString("url", download->GetURL().spec());
-  file_value->SetBoolean("otr", download->is_otr());
-  file_value->SetInteger("total", static_cast<int>(download->total_bytes()));
+  file_value->SetBoolean("otr", download->IsOtr());
+  file_value->SetInteger("total", static_cast<int>(download->GetTotalBytes()));
   file_value->SetBoolean("file_externally_removed",
-                         download->file_externally_removed());
+                         download->GetFileExternallyRemoved());
 
   if (download->IsInProgress()) {
-    if (download->safety_state() == DownloadItem::DANGEROUS) {
+    if (download->GetSafetyState() == DownloadItem::DANGEROUS) {
       file_value->SetString("state", "DANGEROUS");
       DCHECK(download->GetDangerType() == DownloadStateInfo::DANGEROUS_FILE ||
              download->GetDangerType() == DownloadStateInfo::DANGEROUS_URL);
       const char* danger_type_value =
           download->GetDangerType() == DownloadStateInfo::DANGEROUS_FILE ?
           "DANGEROUS_FILE" : "DANGEROUS_URL";
       file_value->SetString("danger_type", danger_type_value);
-    } else if (download->is_paused()) {
+    } else if (download->IsPaused()) {
       file_value->SetString("state", "PAUSED");
     } else {
       file_value->SetString("state", "IN_PROGRESS");
     }
 
     file_value->SetString("progress_status_text",
         GetProgressStatusText(download));
 
     file_value->SetInteger("percent",
         static_cast<int>(download->PercentComplete()));
     file_value->SetInteger("received",
-        static_cast<int>(download->received_bytes()));
+        static_cast<int>(download->GetReceivedBytes()));
   } else if (download->IsInterrupted()) {
     file_value->SetString("state", "INTERRUPTED");
 
     file_value->SetString("progress_status_text",
         GetProgressStatusText(download));
 
     file_value->SetInteger("percent",
         static_cast<int>(download->PercentComplete()));
     file_value->SetInteger("received",
-        static_cast<int>(download->received_bytes()));
+        static_cast<int>(download->GetReceivedBytes()));
   } else if (download->IsCancelled()) {
     file_value->SetString("state", "CANCELLED");
   } else if (download->IsComplete()) {
-    if (download->safety_state() == DownloadItem::DANGEROUS)
+    if (download->GetSafetyState() == DownloadItem::DANGEROUS)
       file_value->SetString("state", "DANGEROUS");
     else
       file_value->SetString("state", "COMPLETE");
-  } else if (download->state() == DownloadItem::REMOVING) {
+  } else if (download->GetState() == DownloadItem::REMOVING) {
     file_value->SetString("state", "REMOVING");
   } else {
     NOTREACHED() << "state undefined";
   }
 
   return file_value;
 }
 
 string16 GetProgressStatusText(DownloadItem* download) {
-  int64 total = download->total_bytes();
-  int64 size = download->received_bytes();
+  int64 total = download->GetTotalBytes();
+  int64 size = download->GetReceivedBytes();
   string16 received_size = ui::FormatBytes(size);
   string16 amount = received_size;
 
   // Adjust both strings for the locale direction since we don't yet know which
   // string we'll end up using for constructing the final progress string.
   base::i18n::AdjustStringForLocaleDirection(&amount);
 
   if (total) {
     string16 total_text = ui::FormatBytes(total);
     base::i18n::AdjustStringForLocaleDirection(&total_text);
 
     base::i18n::AdjustStringForLocaleDirection(&received_size);
     amount = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_TAB_PROGRESS_SIZE,
                                         received_size,
                                         total_text);
   } else {
     amount.assign(received_size);
   }
   int64 current_speed = download->CurrentSpeed();
   string16 speed_text = ui::FormatSpeed(current_speed);
   base::i18n::AdjustStringForLocaleDirection(&speed_text);
 
   base::TimeDelta remaining;
   string16 time_remaining;
-  if (download->is_paused())
+  if (download->IsPaused())
     time_remaining = l10n_util::GetStringUTF16(IDS_DOWNLOAD_PROGRESS_PAUSED);
   else if (download->TimeRemaining(&remaining))
     time_remaining = TimeFormat::TimeRemaining(remaining);
 
   if (time_remaining.empty()) {
     base::i18n::AdjustStringForLocaleDirection(&amount);
     return l10n_util::GetStringFUTF16(
         IDS_DOWNLOAD_TAB_PROGRESS_STATUS_TIME_UNKNOWN, speed_text, amount);
   }
   return l10n_util::GetStringFUTF16(IDS_DOWNLOAD_TAB_PROGRESS_STATUS,
@@ skipping 51 matching lines @@
   return DownloadFile::GetUniquePathNumberWithSuffix(
       path, FILE_PATH_LITERAL(".crdownload"));
 }
 
 FilePath GetCrDownloadPath(const FilePath& suggested_path) {
   return DownloadFile::AppendSuffixToPath(
       suggested_path, FILE_PATH_LITERAL(".crdownload"));
 }
 
 }  // namespace download_util