Convert Task Manager to string16 from wstring, part 1.

BUG=23581
TEST=builds and passes tests

Review URL: http://codereview.chromium.org/3108019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@56138 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 114 insertions, 114 deletions

diff --git a/chrome/browser/cocoa/task_manager_mac.mm b/chrome/browser/cocoa/task_manager_mac.mm
index 526be01..a56195b 100644
--- a/chrome/browser/cocoa/task_manager_mac.mm
+++ b/chrome/browser/cocoa/task_manager_mac.mm
@@ -371,56 +371,56 @@ class SortHelper {
   row = viewToModelMap_[row];
   switch (columnId) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
-      return base::SysWideToNSString(model_->GetResourceTitle(row));
+      return base::SysUTF16ToNSString(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(model_->GetResourcePrivateMemory(row));
+      return base::SysUTF16ToNSString(model_->GetResourcePrivateMemory(row));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(model_->GetResourceSharedMemory(row));
+      return base::SysUTF16ToNSString(model_->GetResourceSharedMemory(row));
 
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(model_->GetResourcePhysicalMemory(row));
+      return base::SysUTF16ToNSString(model_->GetResourcePhysicalMemory(row));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:  // CPU
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(model_->GetResourceCPUUsage(row));
+      return base::SysUTF16ToNSString(model_->GetResourceCPUUsage(row));
 
     case IDS_TASK_MANAGER_NET_COLUMN:  // Net
-      return base::SysWideToNSString(model_->GetResourceNetworkUsage(row));
+      return base::SysUTF16ToNSString(model_->GetResourceNetworkUsage(row));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:  // Process ID
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(model_->GetResourceProcessId(row));
+      return base::SysUTF16ToNSString(model_->GetResourceProcessId(row));
 
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:  // WebCore image cache
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(
+      return base::SysUTF16ToNSString(
           model_->GetResourceWebCoreImageCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:  // WebCore script cache
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(
+      return base::SysUTF16ToNSString(
           model_->GetResourceWebCoreScriptsCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:  // WebCore CSS cache
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
-      return base::SysWideToNSString(
+      return base::SysUTF16ToNSString(
           model_->GetResourceWebCoreCSSCacheSize(row));
 
     case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:  // Goats Teleported!
-      return base::SysWideToNSString(model_->GetResourceGoatsTeleported(row));
+      return base::SysUTF16ToNSString(model_->GetResourceGoatsTeleported(row));
 
     default:
       NOTREACHED();
diff --git a/chrome/browser/gtk/task_manager_gtk.cc b/chrome/browser/gtk/task_manager_gtk.cc
index f3e5987..b476655 100644
--- a/chrome/browser/gtk/task_manager_gtk.cc
+++ b/chrome/browser/gtk/task_manager_gtk.cc
@@ -617,37 +617,37 @@ std::string TaskManagerGtk::GetModelText(int row, int col_id) {
 
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
-      return WideToUTF8(model_->GetResourceTitle(row));
+      return UTF16ToUTF8(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
-      return WideToUTF8(model_->GetResourcePrivateMemory(row));
+      return UTF16ToUTF8(model_->GetResourcePrivateMemory(row));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:  // Memory
-      return WideToUTF8(model_->GetResourceSharedMemory(row));
+      return UTF16ToUTF8(model_->GetResourceSharedMemory(row));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:  // CPU
-      return WideToUTF8(model_->GetResourceCPUUsage(row));
+      return UTF16ToUTF8(model_->GetResourceCPUUsage(row));
 
     case IDS_TASK_MANAGER_NET_COLUMN:  // Net
-      return WideToUTF8(model_->GetResourceNetworkUsage(row));
+      return UTF16ToUTF8(model_->GetResourceNetworkUsage(row));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:  // Process ID
-      return WideToUTF8(model_->GetResourceProcessId(row));
+      return UTF16ToUTF8(model_->GetResourceProcessId(row));
 
     case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
-      return WideToUTF8(model_->GetResourceV8MemoryAllocatedSize(row));
+      return UTF16ToUTF8(model_->GetResourceV8MemoryAllocatedSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
-      return WideToUTF8(model_->GetResourceWebCoreImageCacheSize(row));
+      return UTF16ToUTF8(model_->GetResourceWebCoreImageCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
-      return WideToUTF8(model_->GetResourceWebCoreScriptsCacheSize(row));
+      return UTF16ToUTF8(model_->GetResourceWebCoreScriptsCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
-      return WideToUTF8(model_->GetResourceWebCoreCSSCacheSize(row));
+      return UTF16ToUTF8(model_->GetResourceWebCoreCSSCacheSize(row));
 
     case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:  // Goats Teleported!
-      return WideToUTF8(model_->GetResourceGoatsTeleported(row));
+      return UTF16ToUTF8(model_->GetResourceGoatsTeleported(row));
 
     default:
       NOTREACHED();
diff --git a/chrome/browser/task_manager.cc b/chrome/browser/task_manager.cc
index aca532e..0553ab0 100644
--- a/chrome/browser/task_manager.cc
+++ b/chrome/browser/task_manager.cc
@@ -57,10 +57,10 @@ int ValueCompare(T value1, T value2) {
   return 1;
 }
 
-std::wstring FormatStatsSize(const WebKit::WebCache::ResourceTypeStat& stat) {
-  return l10n_util::GetStringF(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
-      FormatBytes(stat.size, DATA_UNITS_KIBIBYTE, false),
-      FormatBytes(stat.liveSize, DATA_UNITS_KIBIBYTE, false));
+string16 FormatStatsSize(const WebKit::WebCache::ResourceTypeStat& stat) {
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
+      WideToUTF16Hack(FormatBytes(stat.size, DATA_UNITS_KIBIBYTE, false)),
+      WideToUTF16Hack(FormatBytes(stat.liveSize, DATA_UNITS_KIBIBYTE, false)));
 }
 
 }  // namespace
@@ -114,28 +114,28 @@ void TaskManagerModel::RemoveObserver(TaskManagerModelObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-std::wstring TaskManagerModel::GetResourceTitle(int index) const {
+string16 TaskManagerModel::GetResourceTitle(int index) const {
   DCHECK(index < ResourceCount());
-  return resources_[index]->GetTitle();
+  return WideToUTF16Hack(resources_[index]->GetTitle());
 }
 
-std::wstring TaskManagerModel::GetResourceNetworkUsage(int index) const {
+string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
   DCHECK(index < ResourceCount());
   int64 net_usage = GetNetworkUsage(resources_[index]);
   if (net_usage == -1)
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   if (net_usage == 0)
-    return std::wstring(L"0");
+    return ASCIIToUTF16("0");
   std::wstring net_byte =
       FormatSpeed(net_usage, GetByteDisplayUnits(net_usage), true);
   // Force number string to have LTR directionality.
   base::i18n::GetDisplayStringInLTRDirectionality(&net_byte);
-  return net_byte;
+  return WideToUTF16Hack(net_byte);
 }
 
-std::wstring TaskManagerModel::GetResourceCPUUsage(int index) const {
+string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
   DCHECK(index < ResourceCount());
-  return StringPrintf(
+  return WideToUTF16Hack(StringPrintf(
 #if defined(OS_MACOSX)
       // Activity Monitor shows %cpu with one decimal digit -- be
       // consistent with that.
@@ -143,88 +143,87 @@ std::wstring TaskManagerModel::GetResourceCPUUsage(int index) const {
 #else
       L"%.0f",
 #endif
-      GetCPUUsage(resources_[index]));
+      GetCPUUsage(resources_[index])));
 }
 
-std::wstring TaskManagerModel::GetResourcePrivateMemory(int index) const {
+string16 TaskManagerModel::GetResourcePrivateMemory(int index) const {
   size_t private_mem;
   if (!GetPrivateMemory(index, &private_mem))
-    return L"N/A";
+    return ASCIIToUTF16("N/A");
   return GetMemCellText(private_mem);
 }
 
-std::wstring TaskManagerModel::GetResourceSharedMemory(int index) const {
+string16 TaskManagerModel::GetResourceSharedMemory(int index) const {
   size_t shared_mem;
   if (!GetSharedMemory(index, &shared_mem))
-    return L"N/A";
+    return ASCIIToUTF16("N/A");
   return GetMemCellText(shared_mem);
 }
 
-std::wstring TaskManagerModel::GetResourcePhysicalMemory(int index) const {
+string16 TaskManagerModel::GetResourcePhysicalMemory(int index) const {
   size_t phys_mem;
   GetPhysicalMemory(index, &phys_mem);
   return GetMemCellText(phys_mem);
 }
 
-std::wstring TaskManagerModel::GetResourceProcessId(int index) const {
+string16 TaskManagerModel::GetResourceProcessId(int index) const {
   DCHECK(index < ResourceCount());
-  return UTF8ToWide(base::IntToString(base::GetProcId(
-      resources_[index]->GetProcess())));
+  return base::IntToString16(base::GetProcId(resources_[index]->GetProcess()));
 }
 
-std::wstring TaskManagerModel::GetResourceGoatsTeleported(int index) const {
+string16 TaskManagerModel::GetResourceGoatsTeleported(int index) const {
   DCHECK(index < ResourceCount());
-  return UTF16ToWide(base::FormatNumber(GetGoatsTeleported(index)));
+  return base::FormatNumber(GetGoatsTeleported(index));
 }
 
-std::wstring TaskManagerModel::GetResourceWebCoreImageCacheSize(
+string16 TaskManagerModel::GetResourceWebCoreImageCacheSize(
     int index) const {
   DCHECK(index < ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.images);
 }
 
-std::wstring TaskManagerModel::GetResourceWebCoreScriptsCacheSize(
+string16 TaskManagerModel::GetResourceWebCoreScriptsCacheSize(
     int index) const {
   DCHECK(index < ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.scripts);
 }
 
-std::wstring TaskManagerModel::GetResourceWebCoreCSSCacheSize(
+string16 TaskManagerModel::GetResourceWebCoreCSSCacheSize(
     int index) const {
   DCHECK(index < ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.cssStyleSheets);
 }
 
-std::wstring TaskManagerModel::GetResourceSqliteMemoryUsed(int index) const {
+string16 TaskManagerModel::GetResourceSqliteMemoryUsed(int index) const {
   DCHECK(index < ResourceCount());
   if (!resources_[index]->ReportsSqliteMemoryUsed())
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   return GetMemCellText(resources_[index]->SqliteMemoryUsedBytes());
 }
 
-std::wstring TaskManagerModel::GetResourceV8MemoryAllocatedSize(
+string16 TaskManagerModel::GetResourceV8MemoryAllocatedSize(
     int index) const {
   if (!resources_[index]->ReportsV8MemoryStats())
-    return l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT);
-  return l10n_util::GetStringF(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
-      FormatBytes(resources_[index]->GetV8MemoryAllocated(),
-                  DATA_UNITS_KIBIBYTE,
-                  false),
-      FormatBytes(resources_[index]->GetV8MemoryUsed(),
-                  DATA_UNITS_KIBIBYTE,
-                  false));
+    return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
+      WideToUTF16Hack(FormatBytes(resources_[index]->GetV8MemoryAllocated(),
+                                  DATA_UNITS_KIBIBYTE,
+                                  false)),
+      WideToUTF16Hack(FormatBytes(resources_[index]->GetV8MemoryUsed(),
+                                  DATA_UNITS_KIBIBYTE,
+                                  false)));
 }
 
 bool TaskManagerModel::IsResourceFirstInGroup(int index) const {
@@ -282,8 +281,8 @@ int TaskManagerModel::CompareValues(int row1, int row2, int col_id) const {
           NOTREACHED();
         }
       }
-      string16 title1 = WideToUTF16(GetResourceTitle(row1));
-      string16 title2 = WideToUTF16(GetResourceTitle(row2));
+      string16 title1 = GetResourceTitle(row1);
+      string16 title2 = GetResourceTitle(row2);
       UErrorCode compare_status = U_ZERO_ERROR;
       UCollationResult compare_result = collator->compare(
           static_cast<const UChar*>(title1.c_str()),
@@ -469,18 +468,18 @@ int TaskManagerModel::GetGoatsTeleported(int index) const {
   return (seed >> 16) & 255;
 }
 
-std::wstring TaskManagerModel::GetMemCellText(int64 number) const {
+string16 TaskManagerModel::GetMemCellText(int64 number) const {
 #if !defined(OS_MACOSX)
-  std::wstring str = UTF16ToWide(base::FormatNumber(number / 1024));
+  string16 str = base::FormatNumber(number / 1024);
 
   // Adjust number string if necessary.
   base::i18n::AdjustStringForLocaleDirection(str, &str);
-  return l10n_util::GetStringF(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
 #else
   // 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 WideToUTF16Hack(
+      FormatBytes(number, GetByteDisplayUnits(number), /*show_units=*/true));
 #endif
 }
 
diff --git a/chrome/browser/task_manager.h b/chrome/browser/task_manager.h
index 4a92582..c8dd3e6 100644
--- a/chrome/browser/task_manager.h
+++ b/chrome/browser/task_manager.h
@@ -18,6 +18,7 @@
 #include "base/process_util.h"
 #include "base/ref_counted.h"
 #include "base/singleton.h"
+#include "base/string16.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "net/url_request/url_request_job_tracker.h"
@@ -197,19 +198,19 @@ class TaskManagerModel : public URLRequestJobTracker::JobObserver,
   int ResourceCount() const;
 
   // Methods to return formatted resource information.
-  std::wstring GetResourceTitle(int index) const;
-  std::wstring GetResourceNetworkUsage(int index) const;
-  std::wstring GetResourceCPUUsage(int index) const;
-  std::wstring GetResourcePrivateMemory(int index) const;
-  std::wstring GetResourceSharedMemory(int index) const;
-  std::wstring GetResourcePhysicalMemory(int index) const;
-  std::wstring GetResourceProcessId(int index) const;
-  std::wstring GetResourceWebCoreImageCacheSize(int index) const;
-  std::wstring GetResourceWebCoreScriptsCacheSize(int index) const;
-  std::wstring GetResourceWebCoreCSSCacheSize(int index) const;
-  std::wstring GetResourceSqliteMemoryUsed(int index) const;
-  std::wstring GetResourceGoatsTeleported(int index) const;
-  std::wstring GetResourceV8MemoryAllocatedSize(int index) const;
+  string16 GetResourceTitle(int index) const;
+  string16 GetResourceNetworkUsage(int index) const;
+  string16 GetResourceCPUUsage(int index) const;
+  string16 GetResourcePrivateMemory(int index) const;
+  string16 GetResourceSharedMemory(int index) const;
+  string16 GetResourcePhysicalMemory(int index) const;
+  string16 GetResourceProcessId(int index) const;
+  string16 GetResourceWebCoreImageCacheSize(int index) const;
+  string16 GetResourceWebCoreScriptsCacheSize(int index) const;
+  string16 GetResourceWebCoreCSSCacheSize(int index) const;
+  string16 GetResourceSqliteMemoryUsed(int index) const;
+  string16 GetResourceGoatsTeleported(int index) const;
+  string16 GetResourceV8MemoryAllocatedSize(int index) const;
 
   // Returns true if the resource is first in its group (resources
   // rendered by the same process are groupped together).
@@ -359,7 +360,7 @@ class TaskManagerModel : public URLRequestJobTracker::JobObserver,
 
   // Given a number, this function returns the formatted string that should be
   // displayed in the task manager's memory cell.
-  std::wstring GetMemCellText(int64 number) const;
+  string16 GetMemCellText(int64 number) const;
 
   // Looks up the data for |handle| and puts it in the mutable cache
   // |memory_usage_map_|.
diff --git a/chrome/browser/task_manager_browsertest.cc b/chrome/browser/task_manager_browsertest.cc
index 65bd806..f2ab795 100644
--- a/chrome/browser/task_manager_browsertest.cc
+++ b/chrome/browser/task_manager_browsertest.cc
@@ -256,9 +256,9 @@ IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest,
 
   // Check that we get some value for the cache columns.
   DCHECK_NE(model()->GetResourceWebCoreImageCacheSize(2),
-            l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT));
+            l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
   DCHECK_NE(model()->GetResourceWebCoreScriptsCacheSize(2),
-            l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT));
+            l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
   DCHECK_NE(model()->GetResourceWebCoreCSSCacheSize(2),
-            l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT));
+            l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
 }
diff --git a/chrome/browser/task_manager_unittest.cc b/chrome/browser/task_manager_unittest.cc
index d586a5c..0d27ba0 100644
--- a/chrome/browser/task_manager_unittest.cc
+++ b/chrome/browser/task_manager_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -20,9 +20,9 @@ namespace {
 // From task_manager.cc:
 // Activity Monitor shows %cpu with one decimal digit -- be
 // consistent with that.
-const wchar_t *kZeroCPUUsage = L"0.0";
+const char* kZeroCPUUsage = "0.0";
 #else
-const wchar_t *kZeroCPUUsage = L"0";
+const char* kZeroCPUUsage = "0";
 #endif
 
 class TestResource : public TaskManager::Resource {
@@ -66,28 +66,28 @@ TEST_F(TaskManagerTest, Resources) {
   task_manager.AddResource(&resource1);
   ASSERT_EQ(1, model->ResourceCount());
   EXPECT_TRUE(model->IsResourceFirstInGroup(0));
-  EXPECT_STREQ(L"test title", model->GetResourceTitle(0).c_str());
-  EXPECT_STREQ(l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT).c_str(),
-               model->GetResourceNetworkUsage(0).c_str());
-  EXPECT_STREQ(kZeroCPUUsage, model->GetResourceCPUUsage(0).c_str());
+  EXPECT_EQ(ASCIIToUTF16("test title"), model->GetResourceTitle(0));
+  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT),
+            model->GetResourceNetworkUsage(0));
+  EXPECT_EQ(ASCIIToUTF16(kZeroCPUUsage), model->GetResourceCPUUsage(0));
 
   task_manager.AddResource(&resource2);  // Will be in the same group.
   ASSERT_EQ(2, model->ResourceCount());
   EXPECT_TRUE(model->IsResourceFirstInGroup(0));
   EXPECT_FALSE(model->IsResourceFirstInGroup(1));
-  EXPECT_STREQ(L"test title", model->GetResourceTitle(1).c_str());
-  EXPECT_STREQ(l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT).c_str(),
-               model->GetResourceNetworkUsage(1).c_str());
-  EXPECT_STREQ(kZeroCPUUsage, model->GetResourceCPUUsage(1).c_str());
+  EXPECT_EQ(ASCIIToUTF16("test title"), model->GetResourceTitle(1));
+  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT).c_str(),
+            model->GetResourceNetworkUsage(1));
+  EXPECT_EQ(ASCIIToUTF16(kZeroCPUUsage), model->GetResourceCPUUsage(1));
 
   task_manager.RemoveResource(&resource1);
   // Now resource2 will be first in group.
   ASSERT_EQ(1, model->ResourceCount());
   EXPECT_TRUE(model->IsResourceFirstInGroup(0));
-  EXPECT_STREQ(L"test title", model->GetResourceTitle(0).c_str());
-  EXPECT_STREQ(l10n_util::GetString(IDS_TASK_MANAGER_NA_CELL_TEXT).c_str(),
-               model->GetResourceNetworkUsage(0).c_str());
-  EXPECT_STREQ(kZeroCPUUsage, model->GetResourceCPUUsage(0).c_str());
+  EXPECT_EQ(ASCIIToUTF16("test title"), model->GetResourceTitle(0));
+  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT),
+            model->GetResourceNetworkUsage(0));
+  EXPECT_EQ(ASCIIToUTF16(kZeroCPUUsage), model->GetResourceCPUUsage(0));
 
   task_manager.RemoveResource(&resource2);
   EXPECT_EQ(0, model->ResourceCount());
diff --git a/chrome/browser/views/task_manager_view.cc b/chrome/browser/views/task_manager_view.cc
index 59142c3..95a03a9 100644
--- a/chrome/browser/views/task_manager_view.cc
+++ b/chrome/browser/views/task_manager_view.cc
@@ -82,63 +82,63 @@ int TaskManagerTableModel::RowCount() {
 std::wstring TaskManagerTableModel::GetText(int row, int col_id) {
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
-      return model_->GetResourceTitle(row);
+      return UTF16ToWide(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_NET_COLUMN:  // Net
-      return model_->GetResourceNetworkUsage(row);
+      return UTF16ToWide(model_->GetResourceNetworkUsage(row));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:  // CPU
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceCPUUsage(row);
+      return UTF16ToWide(model_->GetResourceCPUUsage(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourcePrivateMemory(row);
+      return UTF16ToWide(model_->GetResourcePrivateMemory(row));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceSharedMemory(row);
+      return UTF16ToWide(model_->GetResourceSharedMemory(row));
 
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourcePhysicalMemory(row);
+      return UTF16ToWide(model_->GetResourcePhysicalMemory(row));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceProcessId(row);
+      return UTF16ToWide(model_->GetResourceProcessId(row));
 
     case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:  // Goats Teleported!
-      return model_->GetResourceGoatsTeleported(row);
+      return UTF16ToWide(model_->GetResourceGoatsTeleported(row));
 
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceWebCoreImageCacheSize(row);
+      return UTF16ToWide(model_->GetResourceWebCoreImageCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceWebCoreScriptsCacheSize(row);
+      return UTF16ToWide(model_->GetResourceWebCoreScriptsCacheSize(row));
 
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceWebCoreCSSCacheSize(row);
+      return UTF16ToWide(model_->GetResourceWebCoreCSSCacheSize(row));
 
     case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceSqliteMemoryUsed(row);
+      return UTF16ToWide(model_->GetResourceSqliteMemoryUsed(row));
 
     case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
       if (!model_->IsResourceFirstInGroup(row))
         return std::wstring();
-      return model_->GetResourceV8MemoryAllocatedSize(row);
+      return UTF16ToWide(model_->GetResourceV8MemoryAllocatedSize(row));
 
     default:
       NOTREACHED();