Remove the LOG_ERROR_REPORT log severity level.

base/logging.cc

 // Copyright (c) 2012 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/logging.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #include <windows.h>
 typedef HANDLE FileHandle;
@@ skipping 56 matching lines @@
 #endif
 
 namespace logging {
 
 namespace {
 
 VlogInfo* g_vlog_info = NULL;
 VlogInfo* g_vlog_info_prev = NULL;
 
 const char* const log_severity_names[LOG_NUM_SEVERITIES] = {
-  "INFO", "WARNING", "ERROR", "ERROR_REPORT", "FATAL" };
+  "INFO", "WARNING", "ERROR", "FATAL" };
 
 const char* log_severity_name(int severity)
 {
   if (severity >= 0 && severity < LOG_NUM_SEVERITIES)
     return log_severity_names[severity];
   return "UNKNOWN";
 }
 
 int min_log_level = 0;
 
@@ skipping 20 matching lines @@
 bool log_thread_id = false;
 bool log_timestamp = true;
 bool log_tickcount = false;
 
 // Should we pop up fatal debug messages in a dialog?
 bool show_error_dialogs = false;
 
 // An assert handler override specified by the client to be called instead of
 // the debug message dialog and process termination.
 LogAssertHandlerFunction log_assert_handler = NULL;
-// An report handler override specified by the client to be called instead of
-// the debug message dialog.
-LogReportHandlerFunction log_report_handler = NULL;
 // A log message handler that gets notified of every log message we process.
 LogMessageHandlerFunction log_message_handler = NULL;
 
 // Helper functions to wrap platform differences.
 
 int32 CurrentProcessId() {
 #if defined(OS_WIN)
   return GetCurrentProcessId();
 #elif defined(OS_POSIX)
   return getpid();
@@ skipping 264 matching lines @@
   if (!log_file_name)
     log_file_name = new PathString();
   *log_file_name = settings.log_file;
   if (settings.delete_old == DELETE_OLD_LOG_FILE)
     DeleteFilePath(*log_file_name);
 
   return InitializeLogFileHandle();
 }
 
 void SetMinLogLevel(int level) {
-  min_log_level = std::min(LOG_ERROR_REPORT, level);
+  min_log_level = std::min(LOG_FATAL, level);
 }
 
 int GetMinLogLevel() {
   return min_log_level;
 }
 
 int GetVlogVerbosity() {
   return std::max(-1, LOG_INFO - GetMinLogLevel());
 }
 
@@ skipping 16 matching lines @@
 }
 
 void SetShowErrorDialogs(bool enable_dialogs) {
   show_error_dialogs = enable_dialogs;
 }
 
 void SetLogAssertHandler(LogAssertHandlerFunction handler) {
   log_assert_handler = handler;
 }
 
-void SetLogReportHandler(LogReportHandlerFunction handler) {
-  log_report_handler = handler;
-}
-
 void SetLogMessageHandler(LogMessageHandlerFunction handler) {
   log_message_handler = handler;
 }
 
 LogMessageHandlerFunction GetLogMessageHandler() {
   return log_message_handler;
 }
 
 // MSVC doesn't like complex extern templates and DLLs.
 #if !defined(COMPILER_MSVC)
 // Explicit instantiations for commonly used comparisons.
 template std::string* MakeCheckOpString<int, int>(
     const int&, const int&, const char* names);
 template std::string* MakeCheckOpString<unsigned long, unsigned long>(
     const unsigned long&, const unsigned long&, const char* names);
 template std::string* MakeCheckOpString<unsigned long, unsigned int>(
     const unsigned long&, const unsigned int&, const char* names);
 template std::string* MakeCheckOpString<unsigned int, unsigned long>(
     const unsigned int&, const unsigned long&, const char* names);
 template std::string* MakeCheckOpString<std::string, std::string>(
     const std::string&, const std::string&, const char* name);
 #endif
 
+#if !defined(NDEBUG)
 // Displays a message box to the user with the error message in it.
 // Used for fatal messages, where we close the app simultaneously.
 // This is for developers only; we don't use this in circumstances
 // (like release builds) where users could see it, since users don't
 // understand these messages anyway.
 void DisplayDebugMessageInDialog(const std::string& str) {
   if (str.empty())
     return;
 
   if (!show_error_dialogs)
@@ skipping 30 matching lines @@
   } else {
     // debug process broken, let's just do a message box
     MessageBoxW(NULL, &cmdline[0], L"Fatal error",
                 MB_OK | MB_ICONHAND | MB_TOPMOST);
   }
 #else
   // We intentionally don't implement a dialog on other platforms.
   // You can just look at stderr.
 #endif
 }
+#endif  // !defined(NDEBUG)
 
 #if defined(OS_WIN)
 LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
 }
 
 LogMessage::SaveLastError::~SaveLastError() {
   ::SetLastError(last_error_);
 }
 #endif  // defined(OS_WIN)
 
@@ skipping 55 matching lines @@
     android_LogPriority priority =
         (severity_ < 0) ? ANDROID_LOG_VERBOSE : ANDROID_LOG_UNKNOWN;
     switch (severity_) {
       case LOG_INFO:
         priority = ANDROID_LOG_INFO;
         break;
       case LOG_WARNING:
         priority = ANDROID_LOG_WARN;
         break;
       case LOG_ERROR:
-      case LOG_ERROR_REPORT:
         priority = ANDROID_LOG_ERROR;
         break;
       case LOG_FATAL:
         priority = ANDROID_LOG_FATAL;
         break;
     }
     __android_log_write(priority, "chromium", str_newline.c_str());
 #endif
     ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
     fflush(stderr);
@@ skipping 48 matching lines @@
       // the debug message process. We also don't display assertions to the
       // user in release mode. The enduser can't do anything with this
       // information, and displaying message boxes when the application is
       // hosed can cause additional problems.
 #ifndef NDEBUG
       DisplayDebugMessageInDialog(stream_.str());
 #endif
       // Crash the process to generate a dump.
       base::debug::BreakDebugger();
     }
-  } else if (severity_ == LOG_ERROR_REPORT) {
-    // We are here only if the user runs with --enable-dcheck in release mode.
-    if (log_report_handler) {
-      log_report_handler(std::string(stream_.str()));
-    } else {
-      DisplayDebugMessageInDialog(stream_.str());
-    }
   }
 }
 
 // writes the common header info to the stream
 void LogMessage::Init(const char* file, int line) {
   base::StringPiece filename(file);
   size_t last_slash_pos = filename.find_last_of("\\/");
   if (last_slash_pos != base::StringPiece::npos)
     filename.remove_prefix(last_slash_pos + 1);
 
@@ skipping 150 matching lines @@
     return *log_file_name;
   return std::wstring();
 }
 #endif
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << base::WideToUTF8(std::wstring(wstr));
 }