Convert FormatBytes to string16.

base/string_util.cc

 // Copyright (c) 2010 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 "base/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 634 matching lines @@
     if (bytes >= kUnitThresholds[unit_index])
       break;
   }
 
   DCHECK(unit_index >= DATA_UNITS_BYTE && unit_index <= DATA_UNITS_GIBIBYTE);
   return DataUnits(unit_index);
 }
 
 // TODO(mpcomplete): deal with locale
 // Byte suffixes.  This must match the DataUnits enum.
-static const wchar_t* const kByteStrings[] = {
-  L"B",
-  L"kB",
-  L"MB",
-  L"GB"
+static const char* const kByteStrings[] = {
+  "B",
+  "kB",
+  "MB",
+  "GB"
 };
 
-static const wchar_t* const kSpeedStrings[] = {
-  L"B/s",
-  L"kB/s",
-  L"MB/s",
-  L"GB/s"
+static const char* const kSpeedStrings[] = {
+  "B/s",
+  "kB/s",
+  "MB/s",
+  "GB/s"
 };
 
-std::wstring FormatBytesInternal(int64 bytes,
-                                 DataUnits units,
-                                 bool show_units,
-                                 const wchar_t* const* suffix) {
+string16 FormatBytesInternal(int64 bytes,
+                             DataUnits units,
+                             bool show_units,
+                             const char* const* suffix) {
   if (bytes < 0) {
     NOTREACHED() << "Negative bytes value";
-    return std::wstring();
+    return string16();
   }
 
   DCHECK(units >= DATA_UNITS_BYTE && units <= DATA_UNITS_GIBIBYTE);
 
   // Put the quantity in the right units.
   double unit_amount = static_cast<double>(bytes);
   for (int i = 0; i < units; ++i)
     unit_amount /= 1024.0;
 
-  wchar_t buf[64];
+  char buf[64];
   if (bytes != 0 && units != DATA_UNITS_BYTE && unit_amount < 100)
-    base::swprintf(buf, arraysize(buf), L"%.1lf", unit_amount);
+    base::snprintf(buf, arraysize(buf), "%.1lf", unit_amount);
   else
-    base::swprintf(buf, arraysize(buf), L"%.0lf", unit_amount);
+    base::snprintf(buf, arraysize(buf), "%.0lf", unit_amount);
 
-  std::wstring ret(buf);
+  std::string ret(buf);
   if (show_units) {
-    ret += L" ";
+    ret += " ";
     ret += suffix[units];
   }
 
-  return ret;
+  return ASCIIToUTF16(ret);
 }
 
-std::wstring FormatBytes(int64 bytes, DataUnits units, bool show_units) {
+string16 FormatBytes(int64 bytes, DataUnits units, bool show_units) {
   return FormatBytesInternal(bytes, units, show_units, kByteStrings);
 }
 
-std::wstring FormatSpeed(int64 bytes, DataUnits units, bool show_units) {
+string16 FormatSpeed(int64 bytes, DataUnits units, bool show_units) {
   return FormatBytesInternal(bytes, units, show_units, kSpeedStrings);
 }
 
 template<class StringType>
 void DoReplaceSubstringsAfterOffset(StringType* str,
                                     typename StringType::size_type start_offset,
                                     const StringType& find_this,
                                     const StringType& replace_with,
                                     bool replace_all) {
   if ((start_offset == StringType::npos) || (start_offset >= str->length()))
@@ skipping 526 matching lines @@
       int rstr_len = (max_len - 3) / 2;
       int lstr_len = rstr_len + ((max_len - 3) % 2);
       output->assign(input.substr(0, lstr_len) + L"..." +
                      input.substr(input.length() - rstr_len));
       break;
     }
   }
 
   return true;
 }