Add video-rendering to mojo media pipeline.

media/renderers/video_renderer_impl.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 "media/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 108 matching lines @@
   start_timestamp_ = timestamp;
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& init_cb,
     CdmContext* cdm_context,
     const StatisticsCB& statistics_cb,
     const BufferingStateCB& buffering_state_cb,
+    const NaturalSizeChangedCB& natural_size_changed_cb,
     const base::Closure& ended_cb,
     const PipelineStatusCB& error_cb,
     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
     const base::Closure& waiting_for_decryption_key_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
@@ skipping 12 matching lines @@
     MEDIA_LOG(DEBUG, media_log_) << "Video rendering in low delay mode.";
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   // Always post |buffering_state_cb_| because it may otherwise invoke reentrant
   // calls to OnTimeStateChanged() under lock, which can deadlock the compositor
   // and media threads.
   buffering_state_cb_ = BindToCurrentLoop(buffering_state_cb);
-
+  natural_size_changed_cb_ = natural_size_changed_cb;
   statistics_cb_ = statistics_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   wall_clock_time_cb_ = wall_clock_time_cb;
   state_ = kInitializing;
 
   video_frame_stream_->Initialize(
       stream, base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                          weak_factory_.GetWeakPtr()),
       cdm_context, statistics_cb, waiting_for_decryption_key_cb);
@@ skipping 65 matching lines @@
                               weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(250));
   }
 
   // Always post this task, it will acquire new frames if necessary and since it
   // happens on another thread, even if we don't have room in the queue now, by
   // the time it runs (may be delayed up to 50ms for complex decodes!) we might.
   task_runner_->PostTask(FROM_HERE, base::Bind(&VideoRendererImpl::AttemptRead,
                                                weak_factory_.GetWeakPtr()));
 
+  // TODO(alokp): Fire NaturalSizeChangedCB if necessary.

[xhwang, 2016/04/12 19:40:38]

This could be related to this comment:
https://code.google.com/p/chromium/codesearch#chromium/src/media/base/video_r...

There are multiple ways to do this:
1. As you proposed, move the natural size tracking logic to this class and fire
the callback here.
2. Keep the logic in VideoFrameCompositor, and pass a NaturalSizeChangedCB in
Start(), such that we only get notified when we are using the new rendering path
(with Start()/Stop). We won't get notified when we are using the old rendering
path.

Thinking more on this, maybe (1) makes more sense...

[alokp, 2016/04/19 00:16:08]

Done.

   return result;
 }
 
 void VideoRendererImpl::OnFrameDropped() {
   base::AutoLock auto_lock(lock_);
   algorithm_->OnLastFrameDropped();
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 379 matching lines @@
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
 }  // namespace media