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

chrome/common/logging_chrome.cc

 // 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 "build/build_config.h"
 
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so render_messages.h will generate the
 // ViewMsgLog et al. functions.
@@ skipping 169 matching lines @@
   // starting a new log, then delete the old symlink and make a new
   // one to a fresh log file.
   FilePath target_path;
   bool symlink_exists = file_util::PathExists(symlink_path);
   if (new_log || !symlink_exists) {
     target_path = GenerateTimestampedName(symlink_path, base::Time::Now());
 
     // We don't care if the unlink fails; we're going to continue anyway.
     if (::unlink(symlink_path.value().c_str()) == -1) {
       if (symlink_exists) // only warn if we might expect it to succeed.
-        PLOG(WARNING) << "Unable to unlink " << symlink_path.value();
+        DPLOG(WARNING) << "Unable to unlink " << symlink_path.value();
     }
     if (!file_util::CreateSymbolicLink(target_path, symlink_path)) {
-      PLOG(ERROR) << "Unable to create symlink " << symlink_path.value()
-                  << " pointing at " << target_path.value();
+      DPLOG(ERROR) << "Unable to create symlink " << symlink_path.value()
+                   << " pointing at " << target_path.value();
     }
   } else {
     if (!file_util::ReadSymbolicLink(symlink_path, &target_path))
-      PLOG(ERROR) << "Unable to read symlink " << symlink_path.value();
+      DPLOG(ERROR) << "Unable to read symlink " << symlink_path.value();
   }
   return target_path;
 }
 
 void RemoveSymlinkAndLog(const FilePath& link_path,
                          const FilePath& target_path) {
   if (::unlink(link_path.value().c_str()) == -1)
-    PLOG(WARNING) << "Unable to unlink symlink " << link_path.value();
+    DPLOG(WARNING) << "Unable to unlink symlink " << link_path.value();
   if (::unlink(target_path.value().c_str()) == -1)
-    PLOG(WARNING) << "Unable to unlink log file " << target_path.value();
+    DPLOG(WARNING) << "Unable to unlink log file " << target_path.value();
 }
 
 }  // anonymous namespace
 
 FilePath GetSessionLogFile(const CommandLine& command_line) {
   FilePath log_dir;
   std::string log_dir_str;
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->GetVar(env_vars::kSessionLogDir, &log_dir_str) &&
       !log_dir_str.empty()) {
@@ skipping 26 matching lines @@
       logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS :
       logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 
   // ChromeOS always logs through the symlink, so it shouldn't be
   // deleted if it already exists.
   if (!InitLogging(log_path.value().c_str(),
                    DetermineLogMode(command_line),
                    logging::LOCK_LOG_FILE,
                    logging::APPEND_TO_OLD_LOG_FILE,
                    dcheck_state)) {
-    LOG(ERROR) << "Unable to initialize logging to " << log_path.value();
+    DLOG(ERROR) << "Unable to initialize logging to " << log_path.value();
     RemoveSymlinkAndLog(log_path, target_path);
   } else {
     chrome_logging_redirected_ = true;
   }
 }
 
 #endif  // OS_CHROMEOS
 
 void InitChromeLogging(const CommandLine& command_line,
                        OldFileDeletionState delete_old_log_file) {
@@ skipping 41 matching lines @@
       logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
 
   bool success = InitLogging(log_path.value().c_str(),
                              logging_dest,
                              logging::LOCK_LOG_FILE,
                              delete_old_log_file,
                              dcheck_state);
 
 #if defined(OS_CHROMEOS)
   if (!success) {
-    PLOG(ERROR) << "Unable to initialize logging to " << log_path.value()
+    DPLOG(ERROR) << "Unable to initialize logging to " << log_path.value()
                 << " (which should be a link to " << target_path.value() << ")";
     RemoveSymlinkAndLog(log_path, target_path);
     chrome_logging_failed_ = true;
     return;
   }
 #else
   if (!success) {
-    PLOG(ERROR) << "Unable to initialize logging to " << log_path.value();
+    DPLOG(ERROR) << "Unable to initialize logging to " << log_path.value();
     chrome_logging_failed_ = true;
     return;
   }
 #endif
 
   // Default to showing error dialogs.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoErrorDialogs))
     logging::SetShowErrorDialogs(true);
 
   // we want process and thread IDs because we have a lot of things running
@@ skipping 14 matching lines @@
   // Use a minimum log level if the command line asks for one,
   // otherwise leave it at the default level (INFO).
   if (command_line.HasSwitch(switches::kLoggingLevel)) {
     std::string log_level = command_line.GetSwitchValueASCII(
         switches::kLoggingLevel);
     int level = 0;
     if (base::StringToInt(log_level, &level) &&
         level >= 0 && level < LOG_NUM_SEVERITIES) {
       logging::SetMinLogLevel(level);
     } else {
-      LOG(WARNING) << "Bad log level: " << log_level;
+      DLOG(WARNING) << "Bad log level: " << log_level;
     }
   }
 
 #if defined(OS_WIN)
   // Enable trace control and transport through event tracing for Windows.
   if (env->HasVar(env_vars::kEtwLogging))
     logging::LogEventProvider::Initialize(kChromeTraceProviderName);
 #endif
 
 #ifdef NDEBUG
@@ skipping 82 matching lines @@
 void DumpWithoutCrashing() {
 #if defined(OS_WIN)
   std::string str;
   DumpProcessAssertHandler(str);
 #else
   NOTIMPLEMENTED();
 #endif  // OS_WIN
 }
 
 }  // namespace logging