Convert base dependencies to use sys_string_conversions instead of the ICU...

base/process_util_mac.mm

 // Copyright (c) 2008 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/process_util.h"
 
 #import <Cocoa/Cocoa.h>
 #include <crt_externs.h>
 #include <mach/mach_init.h>
 #include <mach/task.h>
 #include <spawn.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include <string>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "base/sys_string_conversions.h"
 #include "base/time.h"
 
 namespace base {
 
 void RestoreDefaultExceptionHandler() {
   // This function is tailored to remove the Breakpad exception handler.
   // exception_mask matches s_exception_mask in
   // breakpad/src/client/mac/handler/exception_handler.cc
   const exception_mask_t exception_mask = EXC_MASK_BAD_ACCESS |
                                           EXC_MASK_BAD_INSTRUCTION |
                                           EXC_MASK_ARITHMETIC |
                                           EXC_MASK_BREAKPOINT;
 
   // Setting the exception port to MACH_PORT_NULL may not be entirely
   // kosher to restore the default exception handler, but in practice,
   // it results in the exception port being set to Apple Crash Reporter,
   // the desired behavior.
   task_set_exception_ports(mach_task_self(), exception_mask, MACH_PORT_NULL,
                            EXCEPTION_DEFAULT, THREAD_STATE_NONE);
 }
 
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
                                            const ProcessFilter* filter)
-  : executable_name_(executable_name),
-    index_of_kinfo_proc_(0),
-    filter_(filter) {
+    : executable_name_(executable_name),
+      index_of_kinfo_proc_(0),
+      filter_(filter) {
   // Get a snapshot of all of my processes (yes, as we loop it can go stale, but
   // but trying to find where we were in a constantly changing list is basically
   // impossible.
 
   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, geteuid() };
 
   // Since more processes could start between when we get the size and when
   // we get the list, we do a loop to keep trying until we get it.
   bool done = false;
   int try_num = 1;
@@ skipping 46 matching lines @@
   } while (result && !IncludeEntry());
 
   if (result) {
     return &entry_;
   }
 
   return NULL;
 }
 
 bool NamedProcessIterator::CheckForNextProcess() {
-  std::string executable_name_utf8(WideToUTF8(executable_name_));
+  std::string executable_name_utf8(base::SysWideToUTF8(executable_name_));
 
   std::string data;
   std::string exec_name;
 
   for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
     kinfo_proc* kinfo = &kinfo_procs_[index_of_kinfo_proc_];
 
     // Skip processes just awaiting collection
     if ((kinfo->kp_proc.p_pid > 0) && (kinfo->kp_proc.p_stat == SZOMB))
       continue;
@@ skipping 81 matching lines @@
 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
 }
 
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   return false;
 }
 
 // ------------------------------------------------------------------------
 
 }  // namespace base