media-internals: Differentiate error, info, and debug log messages

media/base/media_log.h

 // 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.
 
 #ifndef MEDIA_BASE_MEDIA_LOG_H_
 #define MEDIA_BASE_MEDIA_LOG_H_
 
 #include <sstream>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
 #include "media/base/media_log_event.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 
 namespace media {
 
-// Indicates a string should be added to the log.
-// First parameter - The string to add to the log.
-typedef base::Callback<void(const std::string&)> LogCB;
-
-// Helper class to make it easier to use log_cb like DVLOG().
-class LogHelper {
- public:
-  LogHelper(const LogCB& Log_cb);
-  ~LogHelper();
-
-  std::ostream& stream() { return stream_; }
-
- private:
-  LogCB log_cb_;
-  std::stringstream stream_;
-};
-
-#define MEDIA_LOG(log_cb) LogHelper(log_cb).stream()
-
-// Logs only while count < max. Increments count for each log. Use LAZY_STREAM
-// to avoid wasteful evaluation of subsequent stream arguments.
-#define LIMITED_MEDIA_LOG(log_cb, count, max) \
-  LAZY_STREAM(MEDIA_LOG(log_cb), (count) < (max) && ((count)++ || true))
 
 class MEDIA_EXPORT MediaLog : public base::RefCountedThreadSafe<MediaLog> {
  public:
+  enum MediaLogLevel {
+    MEDIALOG_ERROR,
+    MEDIALOG_INFO,
+    MEDIALOG_DEBUG,
+  };
+
   // Convert various enums to strings.
+  static std::string MediaLogLevelToString(MediaLogLevel level);
   static std::string EventTypeToString(MediaLogEvent::Type type);
   static std::string PipelineStatusToString(PipelineStatus status);
 
   static std::string MediaEventToLogString(const MediaLogEvent& event);
 
   MediaLog();
 
   // Add an event to this log. Overriden by inheritors to actually do something
   // with it.
   virtual void AddEvent(scoped_ptr<MediaLogEvent> event);
@@ skipping 10 matching lines @@
                                             base::TimeDelta value);
   scoped_ptr<MediaLogEvent> CreateLoadEvent(const std::string& url);
   scoped_ptr<MediaLogEvent> CreateSeekEvent(float seconds);
   scoped_ptr<MediaLogEvent> CreatePipelineStateChangedEvent(
       Pipeline::State state);
   scoped_ptr<MediaLogEvent> CreatePipelineErrorEvent(PipelineStatus error);
   scoped_ptr<MediaLogEvent> CreateVideoSizeSetEvent(
       size_t width, size_t height);
   scoped_ptr<MediaLogEvent> CreateBufferedExtentsChangedEvent(
       int64 start, int64 current, int64 end);
-  scoped_ptr<MediaLogEvent> CreateMediaSourceErrorEvent(
-      const std::string& error);
+  scoped_ptr<MediaLogEvent> CreateLogEvent(MediaLogLevel level,
+                                           const std::string& message);
 
   // Report a property change without an accompanying event.
   void SetStringProperty(const std::string& key, const std::string& value);
   void SetIntegerProperty(const std::string& key, int value);
   void SetDoubleProperty(const std::string& key, double value);
   void SetBooleanProperty(const std::string& key, bool value);
   void SetTimeProperty(const std::string& key, base::TimeDelta value);
 
  protected:
   friend class base::RefCountedThreadSafe<MediaLog>;
   virtual ~MediaLog();
 
  private:
   // A unique (to this process) id for this MediaLog.
   int32 id_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaLog);
 };
 
+// Indicates a string should be added to the log.
+// First parameter - The log level for the string.
+// Second parameter - The string to add to the log.
+typedef base::Callback<void(MediaLog::MediaLogLevel, const std::string&)> LogCB;
+
+// Helper class to make it easier to use log_cb like DVLOG().
+class LogHelper {
+ public:
+  LogHelper(const LogCB& log_cb, MediaLog::MediaLogLevel level);
+  ~LogHelper();
+
+  std::ostream& stream() { return stream_; }
+
+ private:
+  LogCB log_cb_;
+  MediaLog::MediaLogLevel level_;
+  std::stringstream stream_;
+};
+
+// Provides a stringstream to collect a log entry to pass to the provided
+// LogCB at the requested level.
+#define MEDIA_LOG(log_cb, level) \

[DaleCurtis, 2015/03/31 00:12:26]

Hmm, we typically have the level before any other parameters with base::Logging.
What was the reason for point the level second?

[wolenetz, 2015/03/31 00:30:11]

No specific reason. I can change the sequence here in the macro. LogHelper's
.ctor: would it need to change, too?

[DaleCurtis, 2015/03/31 00:34:25]

I think the constructor can stay the same if you decide to change this. I prefer
it with level first, but if I'm the minority it's fine as is.

[wolenetz, 2015/03/31 19:20:22]

Done (level first for both the macros and the .ctor). Thanks!

+  LogHelper((log_cb), (MediaLog::MEDIALOG_ ## level)).stream()
+
+// Logs only while count < max. Increments count for each log. Use LAZY_STREAM
+// to avoid wasteful evaluation of subsequent stream arguments.
+#define LIMITED_MEDIA_LOG(log_cb, level, count, max) \
+  LAZY_STREAM(MEDIA_LOG(log_cb, level), (count) < (max) && ((count)++ || true))
+
 }  // namespace media
 
 #endif  // MEDIA_BASE_MEDIA_LOG_H_