Media: Add MEDIALOG_CREATED event

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 <sstream>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 32 matching lines @@
 namespace content {
 
 RenderMediaLog::RenderMediaLog(const GURL& security_origin)
     : security_origin_(security_origin),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       tick_clock_(new base::DefaultTickClock()),
       last_ipc_send_time_(tick_clock_->NowTicks()),
       ipc_send_pending_(false) {
   DCHECK(RenderThread::Get())
       << "RenderMediaLog must be constructed on the render thread";
+  queued_media_events_.push_back(
+      *CreateEvent(media::MediaLogEvent::MEDIALOG_CREATED));

[wolenetz, 2017/03/21 00:21:26]

In a hypothetical scenario where someone just creates a RenderMediaLog but
delays a long time before doing any ::AddEvent, this MEDIALOG_CREATED event
won't get delivered to the browser until after that long delay. IOW, need to
trigger ipc send pending and the timer, etc (possibly refactoring into helper(s)
l.101-122 might work, or do something one-off here at risk of fragility if the
common case in l.101-122 changes later).

A safer refactor might be to have a private AddEventInternal which is the
current AddEvent, allowed only by the ctor and ::AddEvent, the latter containing
the new DCHECK_NE.

 }
 
 void RenderMediaLog::AddEvent(std::unique_ptr<media::MediaLogEvent> event) {
   Log(event.get());
 
   // For enforcing delay until it's been a second since the last ipc message was
   // sent.
   base::TimeDelta delay_for_next_ipc_send;
 
   {
@@ skipping 21 matching lines @@
         queued_media_events_.push_back(*event);
         last_pipeline_error_.swap(event);
         break;
       case media::MediaLogEvent::MEDIA_ERROR_LOG_ENTRY:
         queued_media_events_.push_back(*event);
         last_media_error_log_entry_.swap(event);
         break;
 
       // Just enqueue all other event types for throttled transmission.
       default:
+        DCHECK_NE(media::MediaLogEvent::MEDIALOG_CREATED, event->type)
+            << "MEDIALOG_CREATED events should not be sent manually";
         queued_media_events_.push_back(*event);
     }
 
     if (ipc_send_pending_)
       return;
 
     ipc_send_pending_ = true;
     delay_for_next_ipc_send = base::TimeDelta::FromSeconds(1) -
                               (tick_clock_->NowTicks() - last_ipc_send_time_);
   }
@@ skipping 76 matching lines @@
   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