Update file version info/memory details/process utils to use string16....

chrome/browser/memory_details_mac.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 "chrome/browser/memory_details.h"
 
 #include <set>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 33 matching lines @@
   SAFARI_BROWSER,
   FIREFOX_BROWSER,
   CAMINO_BROWSER,
   OPERA_BROWSER,
   OMNIWEB_BROWSER,
   MAX_BROWSERS
 } BrowserProcess;
 
 
 MemoryDetails::MemoryDetails() {
-  static const std::wstring google_browser_name =
-      l10n_util::GetString(IDS_PRODUCT_NAME);
+  static const std::string google_browser_name =
+      l10n_util::GetStringUTF8(IDS_PRODUCT_NAME);
   // (Human and process) names of browsers; should match the ordering for
   // |BrowserProcess| (i.e., |BrowserType|).
   // TODO(viettrungluu): The current setup means that we can't detect both
   // Chrome and Chromium at the same time!
   // TODO(viettrungluu): Get localized browser names for other browsers
   // (crbug.com/25779).
   struct {
-    const wchar_t* name;
-    const wchar_t* process_name;
+    const char* name;
+    const char* process_name;
   } process_template[MAX_BROWSERS] = {
     { google_browser_name.c_str(), chrome::kBrowserProcessExecutableName, },
-    { L"Safari", L"Safari", },
-    { L"Firefox", L"firefox-bin", },
-    { L"Camino", L"Camino", },
-    { L"Opera", L"Opera", },
-    { L"OmniWeb", L"OmniWeb", },
+    { "Safari", "Safari", },
+    { "Firefox", "firefox-bin", },
+    { "Camino", "Camino", },
+    { "Opera", "Opera", },
+    { "OmniWeb", "OmniWeb", },
   };
 
   for (size_t index = 0; index < MAX_BROWSERS; ++index) {
     ProcessData process;
-    process.name = process_template[index].name;
-    process.process_name = process_template[index].process_name;
+    process.name = UTF8ToUTF16(process_template[index].name);
+    process.process_name = UTF8ToUTF16(process_template[index].process_name);
     process_data_.push_back(process);
   }
 }
 
 ProcessData* MemoryDetails::ChromeBrowser() {
   return &process_data_[CHROME_BROWSER];
 }
 
 void MemoryDetails::CollectProcessData(
     std::vector<ProcessMemoryInformation> child_info) {
   // This must be run on the file thread to avoid jank (|ProcessInfoSnapshot|
   // runs /bin/ps, which isn't instantaneous).
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Clear old data.
   for (size_t index = 0; index < MAX_BROWSERS; index++)
     process_data_[index].processes.clear();
 
   // First, we use |NamedProcessIterator| to get the PIDs of the processes we're
   // interested in; we save our results to avoid extra calls to
   // |NamedProcessIterator| (for performance reasons) and to avoid additional
   // inconsistencies caused by racing. Then we run |/bin/ps| *once* to get
   // information on those PIDs. Then we used our saved information to iterate
   // over browsers, then over PIDs.
 
   // Get PIDs of main browser processes.
   std::vector<base::ProcessId> pids_by_browser[MAX_BROWSERS];
   std::vector<base::ProcessId> all_pids;
   for (size_t index = CHROME_BROWSER; index < MAX_BROWSERS; index++) {
-    base::NamedProcessIterator process_it(process_data_[index].process_name,
-                                          NULL);
+    base::NamedProcessIterator process_it(
+        UTF16ToUTF8(process_data_[index].process_name), NULL);
 
     while (const base::ProcessEntry* entry = process_it.NextProcessEntry()) {
       pids_by_browser[index].push_back(entry->pid());
       all_pids.push_back(entry->pid());
     }
   }
 
   // Get PIDs of helpers.
   std::vector<base::ProcessId> helper_pids;
   {
@@ skipping 32 matching lines @@
             version_info.reset(FileVersionInfo::CreateFileVersionInfo(
                 bundle_name));
           }
         }
       }
       if (version_info.get()) {
         info.product_name = version_info->product_name();
         info.version = version_info->product_version();
       } else {
         info.product_name = process_data_[index].name;
-        info.version = L"";
+        info.version = string16();
       }
 
       // Memory info.
       process_info.GetCommittedKBytesOfPID(info.pid, &info.committed);
       process_info.GetWorkingSetKBytesOfPID(info.pid, &info.working_set);
 
       // Add the process info to our list.
       process_data_[index].processes.push_back(info);
     }
   }
@@ skipping 23 matching lines @@
     const ProcessInfoSnapshot& process_info) {
   ProcessMemoryInformation info;
   info.pid = pid;
   if (info.pid == base::GetCurrentProcId())
     info.type = ChildProcessInfo::BROWSER_PROCESS;
   else
     info.type = ChildProcessInfo::UNKNOWN_PROCESS;
 
   chrome::VersionInfo version_info;
   if (version_info.is_valid()) {
-    info.product_name = ASCIIToWide(version_info.Name());
-    info.version = ASCIIToWide(version_info.Version());
+    info.product_name = ASCIIToUTF16(version_info.Name());
+    info.version = ASCIIToUTF16(version_info.Version());
   } else {
     info.product_name = process_data_[CHROME_BROWSER].name;
-    info.version = L"";
+    info.version = string16();
   }
 
   // Check if this is one of the child processes whose data we collected
   // on the IO thread, and if so copy over that data.
   for (size_t child = 0; child < child_info.size(); child++) {
     if (child_info[child].pid == info.pid) {
       info.titles = child_info[child].titles;
       info.type = child_info[child].type;
       break;
     }
   }
 
   // Memory info.
   process_info.GetCommittedKBytesOfPID(info.pid, &info.committed);
   process_info.GetWorkingSetKBytesOfPID(info.pid, &info.working_set);
 
   // Add the process info to our list.
   process_data_[CHROME_BROWSER].processes.push_back(info);
 }