Convert chrome/common non-debug logs to debug logs.

chrome/common/service_process_util_mac.mm

 // 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/common/service_process_util_posix.h"
 
 #import <Foundation/Foundation.h>
 #include <launch.h>
 
 #include <vector>
@@ skipping 98 matching lines @@
   return IPC::ChannelHandle(socket_path);
 }
 
 bool ForceServiceProcessShutdown(const std::string& /* version */,
                                  base::ProcessId /* process_id */) {
   base::mac::ScopedNSAutoreleasePool pool;
   CFStringRef label = base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
   CFErrorRef err = NULL;
   bool ret = Launchd::GetInstance()->RemoveJob(label, &err);
   if (!ret) {
-    LOG(ERROR) << "ForceServiceProcessShutdown: " << err << " "
-               << base::SysCFStringRefToUTF8(label);
+    DLOG(ERROR) << "ForceServiceProcessShutdown: " << err << " "
+                << base::SysCFStringRefToUTF8(label);
     CFRelease(err);
   }
   return ret;
 }
 
 bool GetServiceProcessData(std::string* version, base::ProcessId* pid) {
   base::mac::ScopedNSAutoreleasePool pool;
   CFStringRef label = base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
   scoped_nsobject<NSDictionary> launchd_conf(base::mac::CFToNSCast(
       Launchd::GetInstance()->CopyJobDictionary(label)));
   if (!launchd_conf.get()) {
     return false;
   }
   // Anything past here will return true in that there does appear
   // to be a service process of some sort registered with launchd.
   if (version) {
     *version = "0";
     NSString *exe_path = [launchd_conf objectForKey:@ LAUNCH_JOBKEY_PROGRAM];
     if (exe_path) {
       NSString *bundle_path = [[[exe_path stringByDeletingLastPathComponent]
                                 stringByDeletingLastPathComponent]
                                stringByDeletingLastPathComponent];
       NSBundle *bundle = [NSBundle bundleWithPath:bundle_path];
       if (bundle) {
         NSString *ns_version =
             [bundle objectForInfoDictionaryKey:@"CFBundleShortVersionString"];
         if (ns_version) {
           *version = base::SysNSStringToUTF8(ns_version);
         } else {
-          LOG(ERROR) << "Unable to get version at: "
-                     << reinterpret_cast<CFStringRef>(bundle_path);
+          DLOG(ERROR) << "Unable to get version at: "
+                      << reinterpret_cast<CFStringRef>(bundle_path);
         }
       } else {
         // The bundle has been deleted out from underneath the registered
         // job.
-        LOG(ERROR) << "Unable to get bundle at: "
-                   << reinterpret_cast<CFStringRef>(bundle_path);
+        DLOG(ERROR) << "Unable to get bundle at: "
+                    << reinterpret_cast<CFStringRef>(bundle_path);
       }
     } else {
-      LOG(ERROR) << "Unable to get executable path for service process";
+      DLOG(ERROR) << "Unable to get executable path for service process";
     }
   }
   if (pid) {
     *pid = -1;
     NSNumber* ns_pid = [launchd_conf objectForKey:@ LAUNCH_JOBKEY_PID];
     if (ns_pid) {
      *pid = [ns_pid intValue];
     }
   }
   return true;
 }
 
 bool ServiceProcessState::Initialize() {
   CFErrorRef err = NULL;
   CFDictionaryRef dict =
       Launchd::GetInstance()->CopyDictionaryByCheckingIn(&err);
   if (!dict) {
-    LOG(ERROR) << "ServiceProcess must be launched by launchd. "
-               << "CopyLaunchdDictionaryByCheckingIn: " << err;
+    DLOG(ERROR) << "ServiceProcess must be launched by launchd. "
+                << "CopyLaunchdDictionaryByCheckingIn: " << err;
     CFRelease(err);
     return false;
   }
   state_->launchd_conf_.reset(dict);
   return true;
 }
 
 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
-  CHECK(state_);
+  DCHECK(state_);
   NSDictionary *ns_launchd_conf = base::mac::CFToNSCast(state_->launchd_conf_);
   NSDictionary* socket_dict =
       [ns_launchd_conf objectForKey:@ LAUNCH_JOBKEY_SOCKETS];
   NSArray* sockets =
       [socket_dict objectForKey:GetServiceProcessLaunchDSocketKey()];
-  CHECK_EQ([sockets count], 1U);
+  DCHECK_EQ([sockets count], 1U);
   int socket = [[sockets objectAtIndex:0] intValue];
   base::FileDescriptor fd(socket, false);
   return IPC::ChannelHandle(std::string(), fd);
 }
 
 bool CheckServiceProcessReady() {
   std::string version;
   pid_t pid;
   if (!GetServiceProcessData(&version, &pid)) {
     return false;
@@ skipping 101 matching lines @@
 
 bool ServiceProcessState::RemoveFromAutoRun() {
   return RemoveFromLaunchd();
 }
 
 bool ServiceProcessState::StateData::WatchExecutable() {
   base::mac::ScopedNSAutoreleasePool pool;
   NSDictionary* ns_launchd_conf = base::mac::CFToNSCast(launchd_conf_);
   NSString* exe_path = [ns_launchd_conf objectForKey:@ LAUNCH_JOBKEY_PROGRAM];
   if (!exe_path) {
-    LOG(ERROR) << "No " LAUNCH_JOBKEY_PROGRAM;
+    DLOG(ERROR) << "No " LAUNCH_JOBKEY_PROGRAM;
     return false;
   }
 
   FilePath executable_path = FilePath([exe_path fileSystemRepresentation]);
   scoped_ptr<ExecFilePathWatcherDelegate> delegate(
       new ExecFilePathWatcherDelegate);
   if (!delegate->Init(executable_path)) {
-    LOG(ERROR) << "executable_watcher_.Init " << executable_path.value();
+    DLOG(ERROR) << "executable_watcher_.Init " << executable_path.value();
     return false;
   }
   if (!executable_watcher_.Watch(executable_path, delegate.release())) {
-    LOG(ERROR) << "executable_watcher_.watch " << executable_path.value();
+    DLOG(ERROR) << "executable_watcher_.watch " << executable_path.value();
     return false;
   }
   return true;
 }
 
 bool ExecFilePathWatcherDelegate::Init(const FilePath& path) {
   return base::mac::FSRefFromPath(path.value(), &executable_fsref_);
 }
 
 void ExecFilePathWatcherDelegate::OnFilePathChanged(const FilePath& path) {
@@ skipping 58 matching lines @@
         [ns_plist setObject:ns_new_path forKey:@ LAUNCH_JOBKEY_PROGRAM];
         scoped_nsobject<NSMutableArray> args(
             [[ns_plist objectForKey:@ LAUNCH_JOBKEY_PROGRAMARGUMENTS]
              mutableCopy]);
         [args replaceObjectAtIndex:0 withObject:ns_new_path];
         [ns_plist setObject:args forKey:@ LAUNCH_JOBKEY_PROGRAMARGUMENTS];
         if (!Launchd::GetInstance()->WritePlistToFile(Launchd::User,
                                                       Launchd::Agent,
                                                       name,
                                                       plist)) {
-          LOG(ERROR) << "Unable to rewrite plist.";
+          DLOG(ERROR) << "Unable to rewrite plist.";
           needs_shutdown = true;
         }
       } else {
-        LOG(ERROR) << "Unable to read plist.";
+        DLOG(ERROR) << "Unable to read plist.";
         needs_shutdown = true;
       }
     }
     if (needs_shutdown) {
       if (!RemoveFromLaunchd()) {
-        LOG(ERROR) << "Unable to RemoveFromLaunchd.";
+        DLOG(ERROR) << "Unable to RemoveFromLaunchd.";
       }
     }
 
     // Then deal with the process.
     CFStringRef session_type = CFSTR(kServiceProcessSessionType);
     if (needs_restart) {
       if (!Launchd::GetInstance()->RestartJob(Launchd::User,
                                               Launchd::Agent,
                                               name,
                                               session_type)) {
-        LOG(ERROR) << "RestartLaunchdJob";
+        DLOG(ERROR) << "RestartLaunchdJob";
         needs_shutdown = true;
       }
     }
     if (needs_shutdown) {
       CFStringRef label =
           base::mac::NSToCFCast(GetServiceProcessLaunchDLabel());
       CFErrorRef err = NULL;
       if (!Launchd::GetInstance()->RemoveJob(label, &err)) {
         base::mac::ScopedCFTypeRef<CFErrorRef> scoped_err(err);
-        LOG(ERROR) << "RemoveJob " << err;
+        DLOG(ERROR) << "RemoveJob " << err;
         // Exiting with zero, so launchd doesn't restart the process.
         exit(0);
       }
     }
   }
 }