Prime the landing pad for the new video rendering 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
+      sink_(sink),
       video_frame_stream_(
           new VideoFrameStream(task_runner, decoders.Pass(), media_log)),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
@@ skipping 60 matching lines @@
   start_timestamp_ = timestamp;
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
     const PipelineStatusCB& init_cb,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const StatisticsCB& statistics_cb,
     const BufferingStateCB& buffering_state_cb,
-    const PaintCB& paint_cb,
     const base::Closure& ended_cb,
     const PipelineStatusCB& error_cb,
     const 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());
   DCHECK(!buffering_state_cb.is_null());
-  DCHECK(!paint_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!wall_clock_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
 
   low_delay_ = (stream->liveness() == DemuxerStream::LIVENESS_LIVE);
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   statistics_cb_ = statistics_cb;
   buffering_state_cb_ = buffering_state_cb;
-  paint_cb_ = paint_cb,
+  paint_cb_ = base::Bind(&VideoRendererSink::PaintFrameUsingOldRenderingPath,
+                         base::Unretained(sink_));
   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()),
       set_decryptor_ready_cb, statistics_cb, waiting_for_decryption_key_cb);
 }
 
+scoped_refptr<VideoFrame> VideoRendererImpl::Render(
+    base::TimeTicks deadline_min,
+    base::TimeTicks deadline_max) {
+  // TODO(dalecurtis): Hook this up to the new VideoRendererAlgorithm.
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+void VideoRendererImpl::OnFrameDropped() {
+  // TODO(dalecurtis): Hook this up to the new VideoRendererAlgorithm.
+  NOTIMPLEMENTED();
+}
+
 void VideoRendererImpl::CreateVideoThread() {
   // This may fail and cause a crash if there are too many threads created in
   // the current process. See http://crbug.com/443291
   CHECK(base::PlatformThread::Create(0, this, &thread_));
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_.platform_handle(), THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
@@ skipping 304 matching lines @@
     task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, statistics));
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media