CL for perf tryjob on linux

media/renderers/audio_renderer_impl_unittest.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/renderers/audio_renderer_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 114 matching lines @@
     CHECK(!ended_);
     ended_ = true;
   }
   void OnStatisticsUpdate(const PipelineStatistics& stats) override {
     last_statistics_.audio_memory_usage += stats.audio_memory_usage;
   }
   MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
   MOCK_METHOD1(OnVideoNaturalSizeChange, void(const gfx::Size&));
   MOCK_METHOD1(OnVideoOpacityChange, void(bool));
+  MOCK_METHOD3(OnTimeUpdate,
+               void(base::TimeDelta, base::TimeDelta, base::TimeTicks));
 
   void InitializeRenderer(const PipelineStatusCB& pipeline_status_cb) {
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
     EXPECT_CALL(*this, OnVideoNaturalSizeChange(_)).Times(0);
     EXPECT_CALL(*this, OnVideoOpacityChange(_)).Times(0);
     renderer_->Initialize(&demuxer_stream_, nullptr, this, pipeline_status_cb);
   }
 
   void Initialize() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _, _))
@@ skipping 207 matching lines @@
   InputFrames converter_input_frames_left() const {
     return InputFrames(
         renderer_->buffer_converter_->input_frames_left_for_testing());
   }
 
   bool splicer_has_next_buffer() const {
     return renderer_->splicer_->HasNextBuffer();
   }
 
   base::TimeDelta CurrentMediaTime() {
-    return renderer_->CurrentMediaTime();
+    return renderer_->CurrentMediaTime(nullptr);
   }
 
   bool ended() const { return ended_; }
 
   // Fixture members.
   AudioParameters hardware_params_;
   base::MessageLoop message_loop_;
   std::unique_ptr<AudioRendererImpl> renderer_;
   scoped_refptr<FakeAudioRendererSink> sink_;
   base::SimpleTestTickClock* tick_clock_;
@@ skipping 533 matching lines @@
   // Time should change now that the audio hardware has called back.
   const base::TimeTicks wall_clock_time_zero =
       tick_clock_->NowTicks() -
       timestamp_helper.GetFrameDuration(frames_to_consume.value);
   EXPECT_EQ(wall_clock_time_zero,
             ConvertMediaTime(base::TimeDelta(), &is_time_moving));
   EXPECT_TRUE(is_time_moving);
 
   // Store current media time before advancing the tick clock since the call is
   // compensated based on TimeTicks::Now().
-  const base::TimeDelta current_media_time = renderer_->CurrentMediaTime();
+  const base::TimeDelta current_media_time =
+      renderer_->CurrentMediaTime(nullptr);
 
   // The current wall clock time should change as our tick clock advances, up
   // until we've reached the end of played out frames.
   const int kSteps = 4;
   const base::TimeDelta kAdvanceDelta =
       timestamp_helper.GetFrameDuration(frames_to_consume.value) / kSteps;
 
   for (int i = 0; i < kSteps; ++i) {
     tick_clock_->Advance(kAdvanceDelta);
     EXPECT_EQ(tick_clock_->NowTicks(),
@@ skipping 31 matching lines @@
   base::TimeDelta delay_time = base::TimeDelta::FromMicroseconds(
       std::round(delay_frames * kOutputMicrosPerFrame));
 
   frames_to_consume.value = frames_buffered().value / 16;
   EXPECT_TRUE(ConsumeBufferedData(frames_to_consume, delay_frames));
 
   // Verify time is adjusted for the current delay.
   current_time = tick_clock_->NowTicks() + delay_time;
   EXPECT_EQ(current_time, CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
-  EXPECT_EQ(current_time,
-            ConvertMediaTime(renderer_->CurrentMediaTime(), &is_time_moving));
+  EXPECT_EQ(current_time, ConvertMediaTime(renderer_->CurrentMediaTime(nullptr),
+                                           &is_time_moving));
   EXPECT_TRUE(is_time_moving);
 
   tick_clock_->Advance(kOneSample);
   renderer_->SetPlaybackRate(2);
   EXPECT_EQ(current_time, CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
-  EXPECT_EQ(current_time + kOneSample * 2,
-            ConvertMediaTime(renderer_->CurrentMediaTime(), &is_time_moving));
+  EXPECT_EQ(
+      current_time + kOneSample * 2,
+      ConvertMediaTime(renderer_->CurrentMediaTime(nullptr), &is_time_moving));
   EXPECT_TRUE(is_time_moving);
 
   // Advance far enough that we shouldn't be clamped to current time (tested
   // already above).
   tick_clock_->Advance(kOneSecond);
   EXPECT_EQ(
       current_time + timestamp_helper.GetFrameDuration(frames_to_consume.value),
       CurrentMediaWallClockTime(&is_time_moving));
   EXPECT_TRUE(is_time_moving);
 }
 
 }  // namespace media