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

media/base/media_log.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 "media/base/media_log.h"
 
 #include <string>
 
 #include "base/atomic_sequence_num.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/values.h"
 
 namespace media {
 
 // A count of all MediaLogs created in the current process. Used to generate
 // unique IDs.
 static base::StaticAtomicSequenceNumber g_media_log_count;
 
+std::string MediaLog::MediaLogLevelToString(MediaLogLevel level) {
+  switch (level) {
+    case MEDIALOG_ERROR:
+      return "ERROR";
+    case MEDIALOG_INFO:
+      return "INFO";
+    case MEDIALOG_DEBUG:
+      return "DEBUG";
+  }
+  NOTREACHED();
+  return NULL;
+}
+
 std::string MediaLog::EventTypeToString(MediaLogEvent::Type type) {
   switch (type) {
     case MediaLogEvent::WEBMEDIAPLAYER_CREATED:
       return "WEBMEDIAPLAYER_CREATED";
     case MediaLogEvent::WEBMEDIAPLAYER_DESTROYED:
       return "WEBMEDIAPLAYER_DESTROYED";
     case MediaLogEvent::PIPELINE_CREATED:
       return "PIPELINE_CREATED";
     case MediaLogEvent::PIPELINE_DESTROYED:
       return "PIPELINE_DESTROYED";
@@ skipping 16 matching lines @@
     case MediaLogEvent::TOTAL_BYTES_SET:
       return "TOTAL_BYTES_SET";
     case MediaLogEvent::NETWORK_ACTIVITY_SET:
       return "NETWORK_ACTIVITY_SET";
     case MediaLogEvent::ENDED:
       return "ENDED";
     case MediaLogEvent::TEXT_ENDED:
       return "TEXT_ENDED";
     case MediaLogEvent::BUFFERED_EXTENTS_CHANGED:
       return "BUFFERED_EXTENTS_CHANGED";
-    case MediaLogEvent::MEDIA_SOURCE_ERROR:
-      return "MEDIA_SOURCE_ERROR";
+    case MediaLogEvent::MEDIA_ERROR_LOG_ENTRY:
+      return "MEDIA_ERROR_LOG_ENTRY";
+    case MediaLogEvent::MEDIA_INFO_LOG_ENTRY:
+      return "MEDIA_INFO_LOG_ENTRY";
+    case MediaLogEvent::MEDIA_DEBUG_LOG_ENTRY:
+      return "MEDIA_DEBUG_LOG_ENTRY";
     case MediaLogEvent::PROPERTY_CHANGE:
       return "PROPERTY_CHANGE";
   }
   NOTREACHED();
   return NULL;
 }
 
 std::string MediaLog::PipelineStatusToString(PipelineStatus status) {
   switch (status) {
     case PIPELINE_OK:
@@ skipping 40 matching lines @@
       event.params.GetInteger("pipeline_error", &error_code)) {
     PipelineStatus status = static_cast<PipelineStatus>(error_code);
     return EventTypeToString(event.type) + " " +
         media::MediaLog::PipelineStatusToString(status);
   }
   std::string params_json;
   base::JSONWriter::Write(&event.params, &params_json);
   return EventTypeToString(event.type) + " " + params_json;
 }
 
-LogHelper::LogHelper(const LogCB& log_cb) : log_cb_(log_cb) {}
-
-LogHelper::~LogHelper() {
-  if (log_cb_.is_null())
-    return;
-  log_cb_.Run(stream_.str());
-}
-
 MediaLog::MediaLog() : id_(g_media_log_count.GetNext()) {}
 
 MediaLog::~MediaLog() {}
 
 void MediaLog::AddEvent(scoped_ptr<MediaLogEvent> event) {}
 
 scoped_ptr<MediaLogEvent> MediaLog::CreateEvent(MediaLogEvent::Type type) {
   scoped_ptr<MediaLogEvent> event(new MediaLogEvent);
   event->id = id_;
   event->type = type;
@@ skipping 71 matching lines @@
   scoped_ptr<MediaLogEvent> event(
       CreateEvent(MediaLogEvent::BUFFERED_EXTENTS_CHANGED));
   // These values are headed to JS where there is no int64 so we use a double
   // and accept loss of precision above 2^53 bytes (8 Exabytes).
   event->params.SetDouble("buffer_start", start);
   event->params.SetDouble("buffer_current", current);
   event->params.SetDouble("buffer_end", end);
   return event.Pass();
 }
 
-scoped_ptr<MediaLogEvent> MediaLog::CreateMediaSourceErrorEvent(
-    const std::string& error) {
-  scoped_ptr<MediaLogEvent> event(
-      CreateEvent(MediaLogEvent::MEDIA_SOURCE_ERROR));
-  event->params.SetString("error", error);
-  return event.Pass();
+scoped_ptr<MediaLogEvent> MediaLog::CreateLogEvent(MediaLogLevel level,
+                                                   const std::string& message) {
+  switch (level) {
+    case MEDIALOG_ERROR:

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

Just use the MediaLogLevelToString() function instead of a new set of cases?

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

Yeah, I'll update that function to emit e.g. "error" instead of "MEDIALOG_ERROR"
and use it here.

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

Done.

+      {

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

{ with : or did clang-format do this?

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

I did this because otherwise event is declared multiple times in the same scope
and compiler errors.

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

I just meant the style, { should be on the same line as : unless clang-format
did this.

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

I've now git-cl-format'ed the whole thing. It was my bad style previously. I've
also streamlined this method to use a new helper MediaLogLevelToEventType().

+        scoped_ptr<MediaLogEvent> event(
+            CreateEvent(MediaLogEvent::MEDIA_ERROR_LOG_ENTRY));
+        event->params.SetString("error", message);
+        return event.Pass();
+      }
+    case MEDIALOG_INFO:
+      {
+        scoped_ptr<MediaLogEvent> event(
+            CreateEvent(MediaLogEvent::MEDIA_INFO_LOG_ENTRY));
+        event->params.SetString("info", message);
+        return event.Pass();
+      }
+    case MEDIALOG_DEBUG:
+      {
+        scoped_ptr<MediaLogEvent> event(
+            CreateEvent(MediaLogEvent::MEDIA_DEBUG_LOG_ENTRY));
+        event->params.SetString("debug", message);
+        return event.Pass();
+      }
+  }
+  NOTREACHED();
+  return NULL;
 }
 
 void MediaLog::SetStringProperty(
     const std::string& key, const std::string& value) {
   scoped_ptr<MediaLogEvent> event(CreateEvent(MediaLogEvent::PROPERTY_CHANGE));
   event->params.SetString(key, value);
   AddEvent(event.Pass());
 }
 
 void MediaLog::SetIntegerProperty(
@@ skipping 20 matching lines @@
 void MediaLog::SetTimeProperty(
     const std::string& key, base::TimeDelta value) {
   scoped_ptr<MediaLogEvent> event(CreateEvent(MediaLogEvent::PROPERTY_CHANGE));
   if (value.is_max())
     event->params.SetString(key, "unknown");
   else
     event->params.SetDouble(key, value.InSecondsF());
   AddEvent(event.Pass());
 }
 
+LogHelper::LogHelper(const LogCB& log_cb, MediaLog::MediaLogLevel level)
+    : log_cb_(log_cb),
+      level_(level) {
+}
+
+LogHelper::~LogHelper() {
+  if (log_cb_.is_null())
+    return;
+  log_cb_.Run(level_, stream_.str());
+}
+
 }  //namespace media