Revert of media-internals: Simplify the code path for creating a media log entry

content/renderer/media/android/media_source_delegate.cc

 // Copyright 2013 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 "content/renderer/media/android/media_source_delegate.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 22 matching lines @@
 // The size of the access unit to transfer in an IPC in case of MediaSource.
 // 4: approximately 64ms of content in 60 fps movies.
 const size_t kAccessUnitSizeForMediaSource = 4;
 
 const uint8 kVorbisPadding[] = { 0xff, 0xff, 0xff, 0xff };
 
 }  // namespace
 
 namespace content {
 
+static void AddLogEntry(const scoped_refptr<media::MediaLog>& media_log,
+                        media::MediaLog::MediaLogLevel level,
+                        const std::string& message) {
+  media_log->AddEvent(media_log->CreateLogEvent(level, message));
+}
+
 MediaSourceDelegate::MediaSourceDelegate(
     RendererDemuxerAndroid* demuxer_client,
     int demuxer_client_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<media::MediaLog> media_log)
     : demuxer_client_(demuxer_client),
       demuxer_client_id_(demuxer_client_id),
       media_log_(media_log),
       is_demuxer_ready_(false),
       audio_stream_(NULL),
@@ skipping 105 matching lines @@
   duration_change_cb_ = duration_change_cb;
   waiting_for_decryption_key_cb_ =
       media::BindToCurrentLoop(waiting_for_decryption_key_cb);
   access_unit_size_ = kAccessUnitSizeForMediaSource;
 
   chunk_demuxer_.reset(new media::ChunkDemuxer(
       media::BindToCurrentLoop(
           base::Bind(&MediaSourceDelegate::OnDemuxerOpened, main_weak_this_)),
       media::BindToCurrentLoop(base::Bind(
           &MediaSourceDelegate::OnEncryptedMediaInitData, main_weak_this_)),
-      base::Bind(&media::MediaLog::AddLogEvent, media_log_), media_log_,
-      false));
+      base::Bind(&AddLogEntry, media_log_), media_log_, false));
 
   // |this| will be retained until StopDemuxer() is posted, so Unretained() is
   // safe here.
   media_task_runner_->PostTask(FROM_HERE,
                         base::Bind(&MediaSourceDelegate::InitializeDemuxer,
                         base::Unretained(this)));
 }
 
 void MediaSourceDelegate::InitializeDemuxer() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
@@ skipping 478 matching lines @@
 
   return media::ConvertSecondsToTimestamp(duration);
 }
 
 void MediaSourceDelegate::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (media_source_opened_cb_.is_null())
     return;
 
   media_source_opened_cb_.Run(new media::WebMediaSourceImpl(
-      chunk_demuxer_.get(),
-      base::Bind(&media::MediaLog::AddLogEvent, media_log_)));
+      chunk_demuxer_.get(), base::Bind(&AddLogEntry, media_log_)));
 }
 
 void MediaSourceDelegate::OnEncryptedMediaInitData(
     const std::string& init_data_type,
     const std::vector<uint8>& init_data) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (encrypted_media_init_data_cb_.is_null())
     return;
 
   encrypted_media_init_data_cb_.Run(init_data_type, init_data);
@@ skipping 74 matching lines @@
     configs->video_size = config.natural_size();
     configs->is_video_encrypted = config.is_encrypted();
     configs->video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
     return true;
   }
   return false;
 }
 
 }  // namespace content