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);
 }
 
 scoped_refptr<VideoFrame> VideoRendererImpl::Render(
     base::TimeTicks deadline_min,
     base::TimeTicks deadline_max,
     bool background_rendering) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
 
   size_t frames_dropped = 0;
   scoped_refptr<VideoFrame> result =
       algorithm_->Render(deadline_min, deadline_max, &frames_dropped);
 
   // Due to how the |algorithm_| holds frames, this should never be null if
   // we've had a proper startup sequence.
   DCHECK(result);
 
+  if (last_frame_natural_size_ != result->natural_size()) {
+    last_frame_natural_size_ = result->natural_size();
+    task_runner_->PostTask(FROM_HERE, base::Bind(natural_size_changed_cb_,
+                                                 last_frame_natural_size_));
+  }
+
   // Declare HAVE_NOTHING if we reach a state where we can't progress playback
   // any further.  We don't want to do this if we've already done so, reached
   // end of stream, or have frames available.  We also don't want to do this in
   // background rendering mode unless this isn't the first background render
   // tick and we haven't seen any decoded frames since the last one.
   //
   // We use the inverse of |render_first_frame_and_stop_| as a proxy for the
   // value of |time_progressing_| here since we can't access it from the
   // compositor thread.  If we're here (in Render()) the sink must have been
   // started -- but if it was started only to render the first frame and stop,
@@ skipping 37 matching lines @@
         FROM_HERE, base::Bind(&VideoRendererImpl::MaybeStopSinkAfterFirstPaint,
                               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()));
-
   return result;
 }
 
 void VideoRendererImpl::OnFrameDropped() {
   base::AutoLock auto_lock(lock_);
   algorithm_->OnLastFrameDropped();
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 376 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