Convert some non-debug logging on content/common to debug logging.

content/common/sandbox_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 "content/common/sandbox_mac.h"
 
 #import <Cocoa/Cocoa.h>
 
 extern "C" {
 #include <sandbox.h>
@@ skipping 57 matching lines @@
   dst->append(append);
   return true;
 }
 
 // Errors quoting strings for the Sandbox profile are always fatal, report them
 // in a central place.
 NOINLINE void FatalStringQuoteException(const std::string& str) {
   // Copy bad string to the stack so it's recorded in the crash dump.
   char bad_string[256] = {0};
   base::strlcpy(bad_string, str.c_str(), arraysize(bad_string));
-  LOG(FATAL) << "String quoting failed " << bad_string;
+  DLOG(FATAL) << "String quoting failed " << bad_string;
 }
 
 }  // namespace
 
 namespace sandbox {
 
 
 // static
 bool Sandbox::QuotePlainString(const std::string& src_utf8, std::string* dst) {
   dst->clear();
@@ skipping 268 matching lines @@
   // Read in the sandbox profile and the common prefix file.
   NSString* common_sandbox_prefix_path =
       [base::mac::MainAppBundle() pathForResource:@"common"
                                           ofType:@"sb"];
   NSString* common_sandbox_prefix_data =
       [NSString stringWithContentsOfFile:common_sandbox_prefix_path
                                 encoding:NSUTF8StringEncoding
                                    error:NULL];
 
   if (!common_sandbox_prefix_data) {
-    LOG(FATAL) << "Failed to find the sandbox profile on disk "
-               << [common_sandbox_prefix_path fileSystemRepresentation];
+    DLOG(FATAL) << "Failed to find the sandbox profile on disk "
+                << [common_sandbox_prefix_path fileSystemRepresentation];
     return nil;
   }
 
   NSString* sandbox_profile_path =
       [base::mac::MainAppBundle() pathForResource:sandbox_config_filename
                                           ofType:@"sb"];
   NSString* sandbox_data =
       [NSString stringWithContentsOfFile:sandbox_profile_path
                                  encoding:NSUTF8StringEncoding
                                     error:NULL];
 
   if (!sandbox_data) {
-    LOG(FATAL) << "Failed to find the sandbox profile on disk "
-               << [sandbox_profile_path fileSystemRepresentation];
+    DLOG(FATAL) << "Failed to find the sandbox profile on disk "
+                << [sandbox_profile_path fileSystemRepresentation];
     return nil;
   }
 
   // Prefix sandbox_data with common_sandbox_prefix_data.
   return [common_sandbox_prefix_data stringByAppendingString:sandbox_data];
 }
 
 // static
 bool Sandbox::PostProcessSandboxProfile(
         NSString* sandbox_template,
         NSArray* comments_to_remove,
         SandboxVariableSubstitions& substitutions,
         std::string *final_sandbox_profile_str) {
   NSString* sandbox_data = [[sandbox_template copy] autorelease];
 
   // Remove comments, e.g. ;10.6_ONLY .
   for (NSString* to_remove in comments_to_remove) {
     sandbox_data = [sandbox_data stringByReplacingOccurrencesOfString:to_remove
                                                            withString:@""];
   }
 
   // Split string on "@" characters.
   std::vector<std::string> raw_sandbox_pieces;
   if (Tokenize([sandbox_data UTF8String], "@", &raw_sandbox_pieces) == 0) {
-    LOG(FATAL) << "Bad Sandbox profile, should contain at least one token ("
-               << [sandbox_data UTF8String]
-               << ")";
+    DLOG(FATAL) << "Bad Sandbox profile, should contain at least one token ("
+                << [sandbox_data UTF8String]
+                << ")";
     return false;
   }
 
   // Iterate over string pieces and substitute variables, escaping as necessary.
   size_t output_string_length = 0;
   std::vector<std::string> processed_sandbox_pieces(raw_sandbox_pieces.size());
   for (std::vector<std::string>::iterator it = raw_sandbox_pieces.begin();
        it != raw_sandbox_pieces.end();
        ++it) {
     std::string new_piece;
@@ skipping 121 matching lines @@
   std::string final_sandbox_profile_str;
   if (!PostProcessSandboxProfile(sandbox_data, tokens_to_remove, substitutions,
                                  &final_sandbox_profile_str)) {
     return false;
   }
 
   // Initialize sandbox.
   char* error_buff = NULL;
   int error = sandbox_init(final_sandbox_profile_str.c_str(), 0, &error_buff);
   bool success = (error == 0 && error_buff == NULL);
-  LOG_IF(FATAL, !success) << "Failed to initialize sandbox: "
-                          << error
-                          << " "
-                          << error_buff;
+  DLOG_IF(FATAL, !success) << "Failed to initialize sandbox: "
+                           << error
+                           << " "
+                           << error_buff;
   sandbox_free_error(error_buff);
   return success;
 }
 
 // static
 void Sandbox::GetCanonicalSandboxPath(FilePath* path) {
   int fd = HANDLE_EINTR(open(path->value().c_str(), O_RDONLY));
   if (fd < 0) {
-    PLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
-                << path->value();
+    DPLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
+                 << path->value();
     return;
   }
   file_util::ScopedFD file_closer(&fd);
 
   FilePath::CharType canonical_path[MAXPATHLEN];
   if (HANDLE_EINTR(fcntl(fd, F_GETPATH, canonical_path)) != 0) {
-    PLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
-                << path->value();
+    DPLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
+                 << path->value();
     return;
   }
 
   *path = FilePath(canonical_path);
 }
 
 }  // namespace sandbox