Replace most LOG statements with DLOG statements in base.

base/mac/mac_util.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 "base/mac/mac_util.h"
 
 #import <Cocoa/Cocoa.h>
 #include <string.h>
 #include <sys/utsname.h>
 
@@ skipping 46 matching lines @@
 }
 
 // Looks into Shared File Lists corresponding to Login Items for the item
 // representing the current application.  If such an item is found, returns a
 // retained reference to it. Caller is responsible for releasing the reference.
 LSSharedFileListItemRef GetLoginItemForApp() {
   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
       NULL, kLSSharedFileListSessionLoginItems, NULL));
 
   if (!login_items.get()) {
-    LOG(ERROR) << "Couldn't get a Login Items list.";
+    DLOG(ERROR) << "Couldn't get a Login Items list.";
     return NULL;
   }
 
   scoped_nsobject<NSArray> login_items_array(
       CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
 
   NSURL* url = [NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]];
 
   for(NSUInteger i = 0; i < [login_items_array count]; ++i) {
     LSSharedFileListItemRef item = reinterpret_cast<LSSharedFileListItemRef>(
@@ skipping 41 matching lines @@
 bool FSRefFromPath(const std::string& path, FSRef* ref) {
   OSStatus status = FSPathMakeRef((const UInt8*)path.c_str(),
                                   ref, nil);
   return status == noErr;
 }
 
 CGColorSpaceRef GetSRGBColorSpace() {
   // Leaked.  That's OK, it's scoped to the lifetime of the application.
   static CGColorSpaceRef g_color_space_sRGB =
       CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
-  LOG_IF(ERROR, !g_color_space_sRGB) << "Couldn't get the sRGB color space";
+  DLOG_IF(ERROR, !g_color_space_sRGB) << "Couldn't get the sRGB color space";
   return g_color_space_sRGB;
 }
 
 CGColorSpaceRef GetSystemColorSpace() {
   // Leaked.  That's OK, it's scoped to the lifetime of the application.
   // Try to get the main display's color space.
   static CGColorSpaceRef g_system_color_space =
       CGDisplayCopyColorSpace(CGMainDisplayID());
 
   if (!g_system_color_space) {
     // Use a generic RGB color space.  This is better than nothing.
     g_system_color_space = CGColorSpaceCreateDeviceRGB();
 
     if (g_system_color_space) {
-      LOG(WARNING) <<
+      DLOG(WARNING) <<
           "Couldn't get the main display's color space, using generic";
     } else {
-      LOG(ERROR) << "Couldn't get any color space";
+      DLOG(ERROR) << "Couldn't get any color space";
     }
   }
 
   return g_system_color_space;
 }
 
 // Add a request for full screen mode.  Must be called on the main thread.
 void RequestFullScreen(FullScreenMode mode) {
   DCHECK_LT(mode, kNumFullScreenModes);
   if (mode >= kNumFullScreenModes)
@@ skipping 51 matching lines @@
   return !methodImplemented ||
       [NSWindow performSelector:@selector(_shouldMiniaturizeOnDoubleClick)];
 }
 
 void ActivateProcess(pid_t pid) {
   ProcessSerialNumber process;
   OSStatus status = GetProcessForPID(pid, &process);
   if (status == noErr) {
     SetFrontProcess(&process);
   } else {
-    LOG(WARNING) << "Unable to get process for pid " << pid;
+    DLOG(WARNING) << "Unable to get process for pid " << pid;
   }
 }
 
 bool AmIForeground() {
   ProcessSerialNumber foreground_psn = { 0 };
   OSErr err = GetFrontProcess(&foreground_psn);
   if (err != noErr) {
-    LOG(WARNING) << "GetFrontProcess: " << err;
+    DLOG(WARNING) << "GetFrontProcess: " << err;
     return false;
   }
 
   ProcessSerialNumber my_psn = { 0, kCurrentProcess };
 
   Boolean result = FALSE;
   err = SameProcess(&foreground_psn, &my_psn, &result);
   if (err != noErr) {
-    LOG(WARNING) << "SameProcess: " << err;
+    DLOG(WARNING) << "SameProcess: " << err;
     return false;
   }
 
   return result;
 }
 
 bool SetFileBackupExclusion(const FilePath& file_path) {
   NSString* file_path_ns =
       [NSString stringWithUTF8String:file_path.value().c_str()];
   NSURL* file_url = [NSURL fileURLWithPath:file_path_ns];
 
   // When excludeByPath is true the application must be running with root
   // privileges (admin for 10.6 and earlier) but the URL does not have to
   // already exist. When excludeByPath is false the URL must already exist but
   // can be used in non-root (or admin as above) mode. We use false so that
   // non-root (or admin) users don't get their TimeMachine drive filled up with
   // unnecessary backups.
   OSStatus os_err =
       CSBackupSetItemExcluded(base::mac::NSToCFCast(file_url), TRUE, FALSE);
   if (os_err != noErr) {
-    LOG(WARNING) << "Failed to set backup exclusion for file '"
+    DLOG(WARNING) << "Failed to set backup exclusion for file '"
                  << file_path.value().c_str() << "' with error "
                  << os_err << " (" << GetMacOSStatusErrorString(os_err)
                  << ": " << GetMacOSStatusCommentString(os_err)
                  << ").  Continuing.";
   }
   return os_err == noErr;
 }
 
 void SetProcessName(CFStringRef process_name) {
   if (!process_name || CFStringGetLength(process_name) == 0) {
@@ skipping 25 matching lines @@
   static LSSetApplicationInformationItemType
       ls_set_application_information_item_func = NULL;
   static CFStringRef ls_display_name_key = NULL;
 
   static bool did_symbol_lookup = false;
   if (!did_symbol_lookup) {
     did_symbol_lookup = true;
     CFBundleRef launch_services_bundle =
         CFBundleGetBundleWithIdentifier(CFSTR("com.apple.LaunchServices"));
     if (!launch_services_bundle) {
-      LOG(ERROR) << "Failed to look up LaunchServices bundle";
+      DLOG(ERROR) << "Failed to look up LaunchServices bundle";
       return;
     }
 
     ls_get_current_application_asn_func =
         reinterpret_cast<LSGetCurrentApplicationASNType>(
             CFBundleGetFunctionPointerForName(
                 launch_services_bundle, CFSTR("_LSGetCurrentApplicationASN")));
     if (!ls_get_current_application_asn_func)
-      LOG(ERROR) << "Could not find _LSGetCurrentApplicationASN";
+      DLOG(ERROR) << "Could not find _LSGetCurrentApplicationASN";
 
     ls_set_application_information_item_func =
         reinterpret_cast<LSSetApplicationInformationItemType>(
             CFBundleGetFunctionPointerForName(
                 launch_services_bundle,
                 CFSTR("_LSSetApplicationInformationItem")));
     if (!ls_set_application_information_item_func)
-      LOG(ERROR) << "Could not find _LSSetApplicationInformationItem";
+      DLOG(ERROR) << "Could not find _LSSetApplicationInformationItem";
 
     CFStringRef* key_pointer = reinterpret_cast<CFStringRef*>(
         CFBundleGetDataPointerForName(launch_services_bundle,
                                       CFSTR("_kLSDisplayNameKey")));
     ls_display_name_key = key_pointer ? *key_pointer : NULL;
     if (!ls_display_name_key)
-      LOG(ERROR) << "Could not find _kLSDisplayNameKey";
+      DLOG(ERROR) << "Could not find _kLSDisplayNameKey";
 
     // Internally, this call relies on the Mach ports that are started up by the
     // Carbon Process Manager.  In debug builds this usually happens due to how
     // the logging layers are started up; but in release, it isn't started in as
     // much of a defined order.  So if the symbols had to be loaded, go ahead
     // and force a call to make sure the manager has been initialized and hence
     // the ports are opened.
     ProcessSerialNumber psn;
     GetCurrentProcess(&psn);
   }
   if (!ls_get_current_application_asn_func ||
       !ls_set_application_information_item_func ||
       !ls_display_name_key) {
     return;
   }
 
   PrivateLSASN asn = ls_get_current_application_asn_func();
   // Constant used by WebKit; what exactly it means is unknown.
   const int magic_session_constant = -2;
   OSErr err =
       ls_set_application_information_item_func(magic_session_constant, asn,
                                                ls_display_name_key,
                                                process_name,
                                                NULL /* optional out param */);
-  LOG_IF(ERROR, err) << "Call to set process name failed, err " << err;
+  DLOG_IF(ERROR, err) << "Call to set process name failed, err " << err;
 }
 
 // Converts a NSImage to a CGImageRef.  Normally, the system frameworks can do
 // this fine, especially on 10.6.  On 10.5, however, CGImage cannot handle
 // converting a PDF-backed NSImage into a CGImageRef.  This function will
 // rasterize the PDF into a bitmap CGImage.  The caller is responsible for
 // releasing the return value.
 CGImageRef CopyNSImageToCGImage(NSImage* image) {
   // This is based loosely on http://www.cocoadev.com/index.pl?CGImageRef .
   NSSize size = [image size];
@@ skipping 36 matching lines @@
 void AddToLoginItems(bool hide_on_startup) {
   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
   if (item.get() && (IsHiddenLoginItem(item) == hide_on_startup)) {
     return;  // Already is a login item with required hide flag.
   }
 
   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
       NULL, kLSSharedFileListSessionLoginItems, NULL));
 
   if (!login_items.get()) {
-    LOG(ERROR) << "Couldn't get a Login Items list.";
+    DLOG(ERROR) << "Couldn't get a Login Items list.";
     return;
   }
 
   // Remove the old item, it has wrong hide flag, we'll create a new one.
   if (item.get()) {
     LSSharedFileListItemRemove(login_items, item);
   }
 
   NSURL* url = [NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]];
 
   BOOL hide = hide_on_startup ? YES : NO;
   NSDictionary* properties =
       [NSDictionary
         dictionaryWithObject:[NSNumber numberWithBool:hide]
                       forKey:(NSString*)kLSSharedFileListLoginItemHidden];
 
   ScopedCFTypeRef<LSSharedFileListItemRef> new_item;
   new_item.reset(LSSharedFileListInsertItemURL(
       login_items, kLSSharedFileListItemLast, NULL, NULL,
       reinterpret_cast<CFURLRef>(url),
       reinterpret_cast<CFDictionaryRef>(properties), NULL));
 
   if (!new_item.get()) {
-    LOG(ERROR) << "Couldn't insert current app into Login Items list.";
+    DLOG(ERROR) << "Couldn't insert current app into Login Items list.";
   }
 }
 
 void RemoveFromLoginItems() {
   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
   if (!item.get())
     return;
 
   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
       NULL, kLSSharedFileListSessionLoginItems, NULL));
 
   if (!login_items.get()) {
-    LOG(ERROR) << "Couldn't get a Login Items list.";
+    DLOG(ERROR) << "Couldn't get a Login Items list.";
     return;
   }
 
   LSSharedFileListItemRemove(login_items, item);
 }
 
 bool WasLaunchedAsLoginOrResumeItem() {
   ProcessSerialNumber psn = { 0, kCurrentProcess };
 
   scoped_nsobject<NSDictionary> process_info(
@@ skipping 17 matching lines @@
 
 bool WasLaunchedAsHiddenLoginItem() {
   if (!WasLaunchedAsLoginOrResumeItem())
     return false;
 
   ScopedCFTypeRef<LSSharedFileListItemRef> item(GetLoginItemForApp());
   if (!item.get()) {
     // Lion can launch items for the resume feature.  So log an error only for
     // Snow Leopard or earlier.
     if (IsOSSnowLeopardOrEarlier())
-      LOG(ERROR) <<
+      DLOG(ERROR) <<
           "Process launched at Login but can't access Login Item List.";
 
     return false;
   }
   return IsHiddenLoginItem(item);
 }
 
 namespace {
 
 // Returns the running system's Darwin major version. Don't call this, it's
 // an implementation detail and its result is meant to be cached by
 // MacOSXMinorVersion.
 int DarwinMajorVersionInternal() {
   // base::OperatingSystemVersionNumbers calls Gestalt, which is a
   // higher-level operation than is needed. It might perform unnecessary
   // operations. On 10.6, it was observed to be able to spawn threads (see
   // http://crbug.com/53200). It might also read files or perform other
   // blocking operations. Actually, nobody really knows for sure just what
   // Gestalt might do, or what it might be taught to do in the future.
   //
   // uname, on the other hand, is implemented as a simple series of sysctl
   // system calls to obtain the relevant data from the kernel. The data is
   // compiled right into the kernel, so no threads or blocking or other
   // funny business is necessary.
 
   struct utsname uname_info;
   if (uname(&uname_info) != 0) {
-    PLOG(ERROR) << "uname";
+    DPLOG(ERROR) << "uname";
     return 0;
   }
 
   if (strcmp(uname_info.sysname, "Darwin") != 0) {
-    LOG(ERROR) << "unexpected uname sysname " << uname_info.sysname;
+    DLOG(ERROR) << "unexpected uname sysname " << uname_info.sysname;
     return 0;
   }
 
   int darwin_major_version = 0;
   char* dot = strchr(uname_info.release, '.');
   if (dot) {
     if (!base::StringToInt(uname_info.release, dot, &darwin_major_version)) {
       dot = NULL;
     }
   }
 
   if (!dot) {
-    LOG(ERROR) << "could not parse uname release " << uname_info.release;
+    DLOG(ERROR) << "could not parse uname release " << uname_info.release;
     return 0;
   }
 
   return darwin_major_version;
 }
 
 // Returns the running system's Mac OS X minor version. This is the |y| value
 // in 10.y or 10.y.z. Don't call this, it's an implementation detail and the
 // result is meant to be cached by MacOSXMinorVersion.
 int MacOSXMinorVersionInternal() {
   int darwin_major_version = DarwinMajorVersionInternal();
 
   // The Darwin major version is always 4 greater than the Mac OS X minor
   // version for Darwin versions beginning with 6, corresponding to Mac OS X
   // 10.2. Since this correspondence may change in the future, warn when
   // encountering a version higher than anything seen before. Older Darwin
   // versions, or versions that can't be determined, result in
   // immediate death.
   CHECK(darwin_major_version >= 6);
   int mac_os_x_minor_version = darwin_major_version - 4;
-  LOG_IF(WARNING, darwin_major_version > 11) << "Assuming Darwin "
+  DLOG_IF(WARNING, darwin_major_version > 11) << "Assuming Darwin "
       << base::IntToString(darwin_major_version) << " is Mac OS X 10."
       << base::IntToString(mac_os_x_minor_version);
 
   return mac_os_x_minor_version;
 }
 
 // Returns the running system's Mac OS X minor version. This is the |y| value
 // in 10.y or 10.y.z.
 int MacOSXMinorVersion() {
   static int mac_os_x_minor_version = MacOSXMinorVersionInternal();
@@ skipping 51 matching lines @@
 #endif
 
 #if !defined(BASE_MAC_MAC_UTIL_H_INLINED_GT_10_7)
 bool IsOSLaterThanLion() {
   return MacOSXMinorVersion() > LION_MINOR_VERSION;
 }
 #endif
 
 }  // namespace mac
 }  // namespace base