Replace string16 with base::string16.

chrome/browser/download/download_item_model.cc

 // Copyright (c) 2012 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/download_item_model.h"
 
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
@@ skipping 159 matching lines @@
     default:
       string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS;
       break;
   }
 
   return l10n_util::GetStringUTF16(string_id);
 }
 
 string16 InterruptReasonMessage(int reason) {
   int string_id = 0;
-  string16 status_text;
+  base::string16 status_text;
 
   switch (reason) {
     case content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED:
       string_id = IDS_DOWNLOAD_INTERRUPTED_DESCRIPTION_ACCESS_DENIED;
       break;
     case content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE:
       string_id = IDS_DOWNLOAD_INTERRUPTED_DESCRIPTION_DISK_FULL;
       break;
     case content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG:
       string_id = IDS_DOWNLOAD_INTERRUPTED_DESCRIPTION_PATH_TOO_LONG;
@@ skipping 60 matching lines @@
 
 DownloadItemModel::DownloadItemModel(DownloadItem* download)
     : download_(download) {}
 
 DownloadItemModel::~DownloadItemModel() {}
 
 string16 DownloadItemModel::GetInterruptReasonText() const {
   if (download_->GetState() != DownloadItem::INTERRUPTED ||
       download_->GetLastReason() ==
       content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
-    return string16();
+    return base::string16();
   }
   return InterruptReasonMessage(download_->GetLastReason());
 }
 
 string16 DownloadItemModel::GetStatusText() const {
-  string16 status_text;
+  base::string16 status_text;
   switch (download_->GetState()) {
     case DownloadItem::IN_PROGRESS:
       status_text = GetInProgressStatusString();
       break;
     case DownloadItem::COMPLETE:
       if (download_->GetFileExternallyRemoved()) {
         status_text = l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_REMOVED);
       } else {
         status_text.clear();
       }
       break;
     case DownloadItem::CANCELLED:
       status_text = l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_CANCELLED);
       break;
     case DownloadItem::INTERRUPTED: {
       content::DownloadInterruptReason reason = download_->GetLastReason();
       if (reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
-        string16 interrupt_reason = InterruptReasonStatusMessage(reason);
+        base::string16 interrupt_reason = InterruptReasonStatusMessage(reason);
         status_text = l10n_util::GetStringFUTF16(
             IDS_DOWNLOAD_STATUS_INTERRUPTED, interrupt_reason);
       } else {
         // Same as DownloadItem::CANCELLED.
         status_text = l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_CANCELLED);
       }
       break;
     }
     default:
       NOTREACHED();
   }
 
   return status_text;
 }
 
 string16 DownloadItemModel::GetTabProgressStatusText() const {
   int64 total = GetTotalBytes();
   int64 size = download_->GetReceivedBytes();
-  string16 received_size = ui::FormatBytes(size);
-  string16 amount = received_size;
+  base::string16 received_size = ui::FormatBytes(size);
+  base::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::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::string16 speed_text = ui::FormatSpeed(current_speed);
   base::i18n::AdjustStringForLocaleDirection(&speed_text);
 
   base::TimeDelta remaining;
-  string16 time_remaining;
+  base::string16 time_remaining;
   if (download_->IsPaused())
     time_remaining = l10n_util::GetStringUTF16(IDS_DOWNLOAD_PROGRESS_PAUSED);
   else if (download_->TimeRemaining(&remaining))
     time_remaining = ui::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, speed_text, amount, time_remaining);
 }
 
 string16 DownloadItemModel::GetTooltipText(const gfx::FontList& font_list,
                                            int max_width) const {
-  string16 tooltip = gfx::ElideFilename(
+  base::string16 tooltip = gfx::ElideFilename(
       download_->GetFileNameToReportUser(), font_list, max_width);
   content::DownloadInterruptReason reason = download_->GetLastReason();
   if (download_->GetState() == DownloadItem::INTERRUPTED &&
       reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
     tooltip += ASCIIToUTF16("\n");
     tooltip += gfx::ElideText(InterruptReasonStatusMessage(reason),
                              font_list, max_width, gfx::ELIDE_AT_END);
   }
   return tooltip;
 }
 
 string16 DownloadItemModel::GetWarningText(const gfx::FontList& font_list,
                                            int base_width) const {
   // Should only be called if IsDangerous().
   DCHECK(IsDangerous());
-  string16 elided_filename =
+  base::string16 elided_filename =
       gfx::ElideFilename(download_->GetFileNameToReportUser(), font_list,
                         base_width);
   switch (download_->GetDangerType()) {
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL: {
       return l10n_util::GetStringUTF16(IDS_PROMPT_MALICIOUS_DOWNLOAD_URL);
     }
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE: {
       if (download_crx_util::IsExtensionDownload(*download_)) {
         return l10n_util::GetStringUTF16(
             IDS_PROMPT_DANGEROUS_DOWNLOAD_EXTENSION);
@@ skipping 16 matching lines @@
           IDS_PROMPT_DOWNLOAD_CHANGES_SETTINGS, elided_filename);
     }
     case content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS:
     case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
     case content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED:
     case content::DOWNLOAD_DANGER_TYPE_MAX: {
       break;
     }
   }
   NOTREACHED();
-  return string16();
+  return base::string16();
 }
 
 string16 DownloadItemModel::GetWarningConfirmButtonText() const {
   // Should only be called if IsDangerous()
   DCHECK(IsDangerous());
   if (download_->GetDangerType() ==
           content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE &&
       download_crx_util::IsExtensionDownload(*download_)) {
     return l10n_util::GetStringUTF16(IDS_CONTINUE_EXTENSION_DOWNLOAD);
   } else {
@@ skipping 149 matching lines @@
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
   return data && data->should_prefer_opening_in_browser();
 }
 
 void DownloadItemModel::SetShouldPreferOpeningInBrowser(bool preference) {
   DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
   data->set_should_prefer_opening_in_browser(preference);
 }
 
 string16 DownloadItemModel::GetProgressSizesString() const {
-  string16 size_ratio;
+  base::string16 size_ratio;
   int64 size = GetCompletedBytes();
   int64 total = GetTotalBytes();
   if (total > 0) {
     ui::DataUnits amount_units = ui::GetByteDisplayUnits(total);
-    string16 simple_size = ui::FormatBytesWithUnits(size, amount_units, false);
+    base::string16 simple_size = ui::FormatBytesWithUnits(size, amount_units, false);
 
     // In RTL locales, we render the text "size/total" in an RTL context. This
     // is problematic since a string such as "123/456 MB" is displayed
     // as "MB 123/456" because it ends with an LTR run. In order to solve this,
     // we mark the total string as an LTR string if the UI layout is
     // right-to-left so that the string "456 MB" is treated as an LTR run.
-    string16 simple_total = base::i18n::GetDisplayStringInLTRDirectionality(
+    base::string16 simple_total = base::i18n::GetDisplayStringInLTRDirectionality(
         ui::FormatBytesWithUnits(total, amount_units, true));
     size_ratio = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_STATUS_SIZES,
                                             simple_size, simple_total);
   } else {
     size_ratio = ui::FormatBytes(size);
   }
   return size_ratio;
 }
 
 string16 DownloadItemModel::GetInProgressStatusString() const {
   DCHECK_EQ(DownloadItem::IN_PROGRESS, download_->GetState());
 
   TimeDelta time_remaining;
   // time_remaining is only known if the download isn't paused.
   bool time_remaining_known = (!download_->IsPaused() &&
                                download_->TimeRemaining(&time_remaining));
 
   // Indication of progress. (E.g.:"100/200 MB" or "100MB")
-  string16 size_ratio = GetProgressSizesString();
+  base::string16 size_ratio = GetProgressSizesString();
 
   // The download is a CRX (app, extension, theme, ...) and it is being unpacked
   // and validated.
   if (download_->AllDataSaved() &&
       download_crx_util::IsExtensionDownload(*download_)) {
     return l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_CRX_INSTALL_RUNNING);
   }
 
   // A paused download: "100/120 MB, Paused"
   if (download_->IsPaused()) {
@@ skipping 35 matching lines @@
   if (!download_service)
     return;
 
   ChromeDownloadManagerDelegate* delegate =
       download_service->GetDownloadManagerDelegate();
   if (!delegate)
     return;
   delegate->OpenDownloadUsingPlatformHandler(download_);
   RecordDownloadOpenMethod(DOWNLOAD_OPEN_METHOD_USER_PLATFORM);
 }