Refactor VideoRendererImpl to use VideoFrameScheduler.

media/filters/pipeline_integration_test_base.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 "media/filters/pipeline_integration_test_base.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
-#include "media/base/clock.h"
 #include "media/base/media_log.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "media/filters/chunk_demuxer.h"
+#include "media/filters/clockless_video_frame_scheduler.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/file_data_source.h"
 #include "media/filters/opus_audio_decoder.h"
+#include "media/filters/video_frame_scheduler_impl.h"
 #include "media/filters/vpx_video_decoder.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtMost;
 using ::testing::SaveArg;
 
 namespace media {
 
 const char kNullVideoHash[] = "d41d8cd98f00b204e9800998ecf8427e";
@@ skipping 91 matching lines @@
       base::Closure());
   message_loop_.Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 bool PipelineIntegrationTestBase::Start(const base::FilePath& file_path,
                                         PipelineStatus expected_status,
                                         kTestType test_type) {
   hashing_enabled_ = test_type == kHashed;
   clockless_playback_ = test_type == kClockless;
-  if (clockless_playback_) {
-    pipeline_->SetClockForTesting(new Clock(&dummy_clock_));
-  }
   return Start(file_path, expected_status);
 }
 
 bool PipelineIntegrationTestBase::Start(const base::FilePath& file_path) {
   return Start(file_path, NULL);
 }
 
 bool PipelineIntegrationTestBase::Start(const base::FilePath& file_path,
                                         Decryptor* decryptor) {
   EXPECT_CALL(*this, OnMetadata(_)).Times(AtMost(1))
@@ skipping 94 matching lines @@
 
   scoped_ptr<FilterCollection> collection(new FilterCollection());
   collection->SetDemuxer(demuxer_.get());
 
   ScopedVector<VideoDecoder> video_decoders;
   video_decoders.push_back(
       new VpxVideoDecoder(message_loop_.message_loop_proxy()));
   video_decoders.push_back(
       new FFmpegVideoDecoder(message_loop_.message_loop_proxy()));
 
-  // Disable frame dropping if hashing is enabled.
+  scoped_ptr<VideoFrameScheduler> scheduler;
+  if (!clockless_playback_) {
+    scheduler.reset(new VideoFrameSchedulerImpl(
+        message_loop_.message_loop_proxy(),
+        base::Bind(&PipelineIntegrationTestBase::OnVideoRendererPaint,
+                   base::Unretained(this))));
+  } else {
+    scheduler.reset(new ClocklessVideoFrameScheduler(
+        base::Bind(&PipelineIntegrationTestBase::OnVideoRendererPaint,
+                   base::Unretained(this))));
+  }
+
   scoped_ptr<VideoRenderer> renderer(new VideoRendererImpl(
       message_loop_.message_loop_proxy(),
+      scheduler.Pass(),
       video_decoders.Pass(),
       base::Bind(&PipelineIntegrationTestBase::SetDecryptor,
                  base::Unretained(this),
-                 decryptor),
-      base::Bind(&PipelineIntegrationTestBase::OnVideoRendererPaint,
-                 base::Unretained(this)),
-      false));
+                 decryptor)));
   collection->SetVideoRenderer(renderer.Pass());
 
   if (!clockless_playback_) {
     audio_sink_ = new NullAudioSink(message_loop_.message_loop_proxy());
   } else {
     clockless_audio_sink_ = new ClocklessAudioSink();
   }
 
   ScopedVector<AudioDecoder> audio_decoders;
   audio_decoders.push_back(
@@ skipping 53 matching lines @@
 std::string PipelineIntegrationTestBase::GetAudioHash() {
   DCHECK(hashing_enabled_);
   return audio_sink_->GetAudioHashForTesting();
 }
 
 base::TimeDelta PipelineIntegrationTestBase::GetAudioTime() {
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
-base::TimeTicks DummyTickClock::NowTicks() {
-  now_ += base::TimeDelta::FromSeconds(60);
-  return now_;
-}
-
 }  // namespace media