Localize strings, speeds.

chrome/browser/task_manager/task_manager.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/task_manager/task_manager.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
@@ skipping 18 matching lines @@
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/result_codes.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/base/text/bytes_formatting.h"
 #include "unicode/coll.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/mach_broker_mac.h"
 #endif
 
 namespace {
 
 // The delay between updates of the information (in ms).
 #if defined(OS_MACOSX)
 // Match Activity Monitor's default refresh rate.
 const int kUpdateTimeMs = 2000;
 #else
 const int kUpdateTimeMs = 1000;
 #endif
 
 template <class T>
 int ValueCompare(T value1, T value2) {
   if (value1 < value2)
     return -1;
   if (value1 == value2)
     return 0;
   return 1;
 }
 
 string16 FormatStatsSize(const WebKit::WebCache::ResourceTypeStat& stat) {
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
-      FormatBytes(stat.size, DATA_UNITS_KIBIBYTE, false),
-      FormatBytes(stat.liveSize, DATA_UNITS_KIBIBYTE, false));
+      ui::FormatBytesWithUnits(stat.size, ui::DATA_UNITS_KIBIBYTE, false),
+      ui::FormatBytesWithUnits(stat.liveSize, ui::DATA_UNITS_KIBIBYTE, false));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : update_requests_(0),
@@ skipping 43 matching lines @@
   CHECK_LT(index, ResourceCount());
   return GetNetworkUsage(resources_[index]);
 }
 
 string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
   int64 net_usage = GetNetworkUsage(index);
   if (net_usage == -1)
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   if (net_usage == 0)
     return ASCIIToUTF16("0");
-  string16 net_byte = FormatSpeed(net_usage, GetByteDisplayUnits(net_usage),
-                                  true);
+  string16 net_byte = ui::FormatSpeed(net_usage);
   // Force number string to have LTR directionality.
   return base::i18n::GetDisplayStringInLTRDirectionality(net_byte);
 }
 
 double TaskManagerModel::GetCPUUsage(int index) const {
   CHECK_LT(index, ResourceCount());
   return GetCPUUsage(resources_[index]);
 }
 
 string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
@@ skipping 87 matching lines @@
   if (!resources_[index]->ReportsSqliteMemoryUsed())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   return GetMemCellText(resources_[index]->SqliteMemoryUsedBytes());
 }
 
 string16 TaskManagerModel::GetResourceV8MemoryAllocatedSize(
     int index) const {
   if (!resources_[index]->ReportsV8MemoryStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
-      FormatBytes(resources_[index]->GetV8MemoryAllocated(),
-                  DATA_UNITS_KIBIBYTE,
-                  false),
-      FormatBytes(resources_[index]->GetV8MemoryUsed(),
-                  DATA_UNITS_KIBIBYTE,
-                  false));
+      ui::FormatBytesWithUnits(resources_[index]->GetV8MemoryAllocated(),
+                               ui::DATA_UNITS_KIBIBYTE,
+                               false),
+      ui::FormatBytesWithUnits(resources_[index]->GetV8MemoryUsed(),
+                               ui::DATA_UNITS_KIBIBYTE,
+                               false));
 }
 
 bool TaskManagerModel::IsResourceFirstInGroup(int index) const {
   CHECK_LT(index, ResourceCount());
   TaskManager::Resource* resource = resources_[index];
   GroupMap::const_iterator iter = group_map_.find(resource->GetProcess());
   DCHECK(iter != group_map_.end());
   const ResourceList* group = iter->second;
   return ((*group)[0] == resource);
 }
@@ skipping 226 matching lines @@
 }
 
 string16 TaskManagerModel::GetMemCellText(int64 number) const {
 #if !defined(OS_MACOSX)
   string16 str = base::FormatNumber(number / 1024);
 
   // Adjust number string if necessary.
   base::i18n::AdjustStringForLocaleDirection(&str);
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
 #else
-  // System expectation is to show "100 KB", "200 MB", etc.
+  // System expectation is to show "100 kB", "200 MB", etc.
   // TODO(thakis): Switch to metric units (as opposed to powers of two).
-  return FormatBytes(number, GetByteDisplayUnits(number), /*show_units=*/true);
+  return ui::FormatBytes(number);
 #endif
 }
 
 void TaskManagerModel::StartUpdating() {
   // Multiple StartUpdating requests may come in, and we only need to take
   // action the first time.
   update_requests_++;
   if (update_requests_ > 1)
     return;
   DCHECK_EQ(1, update_requests_);
@@ skipping 528 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }