MSE: Log buffered audio splice generation to media-internals

content/renderer/media/render_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 "content/renderer/media/render_media_log.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 37 matching lines @@
                                     base::Passed(&event)));
 }
 
 void RenderMediaLog::AddEventInternal(scoped_ptr<media::MediaLogEvent> event) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   Log(event.get());
 
   // If there is an event waiting to be sent, there must be a send task pending.
   const bool delayed_ipc_send_pending =
-      !queued_media_events_.empty() || last_buffered_extents_changed_event_;
+      !queued_media_events_.empty() || last_buffered_extents_changed_event_ ||
+      last_buffered_audio_splice_stats_changed_event_;
 
   // Keep track of the latest buffered extents properties to avoid sending
   // thousands of events over IPC. See http://crbug.com/352585 for details.
-  if (event->type == media::MediaLogEvent::BUFFERED_EXTENTS_CHANGED)
+  if (event->type == media::MediaLogEvent::BUFFERED_EXTENTS_CHANGED) {
     last_buffered_extents_changed_event_.swap(event);
-  else
+  } else if (event->type ==
+             media::MediaLogEvent::BUFFERED_AUDIO_SPLICE_STATISTICS_CHANGED) {
+    last_buffered_audio_splice_stats_changed_event_.swap(event);
+  } else {
     queued_media_events_.push_back(*event);
+  }
 
   if (delayed_ipc_send_pending)
     return;
 
   // Delay until it's been a second since the last ipc message was sent.
   base::TimeDelta delay_for_next_ipc_send =
       base::TimeDelta::FromSeconds(1) -
       (tick_clock_->NowTicks() - last_ipc_send_time_);
   if (delay_for_next_ipc_send > base::TimeDelta()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&RenderMediaLog::SendQueuedMediaEvents, this),
         delay_for_next_ipc_send);
     return;
   }
 
   // It's been more than a second so send now.
   SendQueuedMediaEvents();
 }
 
 void RenderMediaLog::SendQueuedMediaEvents() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (last_buffered_extents_changed_event_) {
     queued_media_events_.push_back(*last_buffered_extents_changed_event_);
     last_buffered_extents_changed_event_.reset();
   }
 
+  if (last_buffered_audio_splice_stats_changed_event_) {
+    queued_media_events_.push_back(
+        *last_buffered_audio_splice_stats_changed_event_);
+    last_buffered_audio_splice_stats_changed_event_.reset();
+  }
+
   RenderThread::Get()->Send(
       new ViewHostMsg_MediaLogEvents(queued_media_events_));
   queued_media_events_.clear();
   last_ipc_send_time_ = tick_clock_->NowTicks();
 }
 
 RenderMediaLog::~RenderMediaLog() {
 }
 
 void RenderMediaLog::SetTickClockForTesting(
     scoped_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
   last_ipc_send_time_ = tick_clock_->NowTicks();
 }
 
 void RenderMediaLog::SetTaskRunnerForTesting(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   task_runner_ = task_runner;
 }
 
 }  // namespace content