Enable DVLOG on non official release build based on the parameter passed for InitLogging.

base/logging.h

 // 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.
 
 #ifndef BASE_LOGGING_H_
 #define BASE_LOGGING_H_
 #pragma once
 
 #include <cassert>
 #include <string>
@@ skipping 155 matching lines @@
 
 // On startup, should we delete or append to an existing log file (if any)?
 // Defaults to APPEND_TO_OLD_LOG_FILE.
 enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE };
 
 enum DcheckState {
   DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS,
   ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS
 };
 
+enum DlogState {
+  DISABLE_DLOG_FOR_NON_OFFICIAL_RELEASE_BUILDS,
+  ENABLE_DLOG_FOR_NON_OFFICIAL_RELEASE_BUILDS
+};
+
 // TODO(avi): do we want to do a unification of character types here?
 #if defined(OS_WIN)
 typedef wchar_t PathChar;
 #else
 typedef char PathChar;
 #endif
 
 // Define different names for the BaseInitLoggingImpl() function depending on
 // whether NDEBUG is defined or not so that we'll fail to link if someone tries
 // to compile logging.cc with NDEBUG but includes logging.h without defining it,
 // or vice versa.
 #if NDEBUG
 #define BaseInitLoggingImpl BaseInitLoggingImpl_built_with_NDEBUG
 #else
 #define BaseInitLoggingImpl BaseInitLoggingImpl_built_without_NDEBUG
 #endif
 
 // Implementation of the InitLogging() method declared below.  We use a
 // more-specific name so we can #define it above without affecting other code
 // that has named stuff "InitLogging".
 BASE_EXPORT bool BaseInitLoggingImpl(const PathChar* log_file,
                                      LoggingDestination logging_dest,
                                      LogLockingState lock_log,
                                      OldFileDeletionState delete_old,
-                                     DcheckState dcheck_state);
+                                     DcheckState dcheck_state,
+                                     DlogState dlog_state);
 
 // Sets the log file name and other global logging state. Calling this function
 // is recommended, and is normally done at the beginning of application init.
 // If you don't call it, all the flags will be initialized to their default
 // values, and there is a race condition that may leak a critical section
 // object if two threads try to do the first log at the same time.
 // See the definition of the enums above for descriptions and default values.
 //
 // The default log file is initialized to "debug.log" in the application
 // directory. You probably don't want this, especially since the program
 // directory may not be writable on an enduser's system.
 inline bool InitLogging(const PathChar* log_file,
                         LoggingDestination logging_dest,
                         LogLockingState lock_log,
                         OldFileDeletionState delete_old,
-                        DcheckState dcheck_state) {
+                        DcheckState dcheck_state,
+                        DlogState dlog_state) {
   return BaseInitLoggingImpl(log_file, logging_dest, lock_log,
-                             delete_old, dcheck_state);
+                             delete_old, dcheck_state, dlog_state);
 }
 
 // Sets the log level. Anything at or above this level will be written to the
 // log file/displayed to the user (if applicable). Anything below this level
 // will be silently ignored. The log level defaults to 0 (everything is logged
 // up to level INFO) if this function is not called.
 // Note that log messages for VLOG(x) are logged at level -x, so setting
 // the min log level to negative values enables verbose logging.
 BASE_EXPORT void SetMinLogLevel(int level);
 
@@ skipping 306 matching lines @@
 #if ( defined(OS_WIN) && defined(OFFICIAL_BUILD)) || \
     (!defined(OS_WIN) && defined(NDEBUG) && defined(GOOGLE_CHROME_BUILD))
 // Used by unit tests.
 #define LOGGING_IS_OFFICIAL_BUILD
 
 // In order to have optimized code for official builds, remove DLOGs and
 // DCHECKs.
 #define ENABLE_DLOG 0
 #define ENABLE_DCHECK 0
 
-#elif defined(NDEBUG)
-// Otherwise, if we're a release build, remove DLOGs but not DCHECKs
-// (since those can still be turned on via a command-line flag).
-#define ENABLE_DLOG 0
-#define ENABLE_DCHECK 1
-
 #else
-// Otherwise, we're a debug build so enable DLOGs and DCHECKs.
+// For both non offical release builds and debug builds we enable them.
+// In case of non official release builds they could be enabled by commandline.
 #define ENABLE_DLOG 1
 #define ENABLE_DCHECK 1
 #endif
 
 // Definitions for DLOG et al.
 
 #if ENABLE_DLOG
 
+#if defined(NDEBUG)
+BASE_EXPORT extern DlogState g_dlog_state;
+
+#define DLOG_ENABLED (::logging::g_dlog_state == \
+  ::logging::ENABLE_DLOG_FOR_NON_OFFICIAL_RELEASE_BUILDS)
+#define DLOG_IS_ON(severity) (DLOG_ENABLED && LOG_IS_ON(severity))
+#define DLOG_IF(severity, condition) \
+  LOG_IF(severity,(DLOG_IS_ON(severity) && condition))
+#define DLOG_ASSERT(condition) LOG_ASSERT(DLOG_ENABLED && condition)
+#define DPLOG_IF(severity, condition) PLOG_IF(severity, \
+  (DLOG_IS_ON(severity) && condition))
+#define DVLOG_IF(verboselevel, condition) \
+  VLOG_IF(verboselevel, (DLOG_ENABLED && condition))
+#define DVPLOG_IF(verboselevel, condition) \
+  VPLOG_IF(verboselevel, (DLOG_ENABLED && condition))
+#else  // NDEBUG
+// Debug builds.
 #define DLOG_IS_ON(severity) LOG_IS_ON(severity)
 #define DLOG_IF(severity, condition) LOG_IF(severity, condition)
 #define DLOG_ASSERT(condition) LOG_ASSERT(condition)
 #define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
 #define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
 #define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
 
+#endif  // NDEBUG
+
 #else  // ENABLE_DLOG
 
 // If ENABLE_DLOG is off, we want to avoid emitting any references to
 // |condition| (which may reference a variable defined only if NDEBUG
 // is not defined).  Contrast this with DCHECK et al., which has
 // different behavior.
 
 #define DLOG_EAT_STREAM_PARAMETERS                                      \
   true ? (void) 0 : ::logging::LogMessageVoidify() & LOG_STREAM(FATAL)
 
@@ skipping 377 matching lines @@
 namespace base {
 
 class StringPiece;
 
 // Allows StringPiece to be logged.
 BASE_EXPORT std::ostream& operator<<(std::ostream& o, const StringPiece& piece);
 
 }  // namespace base
 
 #endif  // BASE_LOGGING_H_