Make base::Timer sequence-friendly.

media/base/android/media_codec_loop_unittest.cc

 // Copyright 2016 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/base/android/media_codec_loop.h"
+
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "media/base/android/media_codec_bridge.h"
-#include "media/base/android/media_codec_loop.h"
 #include "media/base/android/mock_media_codec_bridge.h"
-#include "media/base/fake_single_thread_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::Eq;
 using ::testing::Field;
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::Return;
@@ skipping 18 matching lines @@
   MOCK_METHOD1(OnInputDataQueued, void(bool));
   MOCK_METHOD1(OnDecodedEos, void(const MediaCodecLoop::OutputBuffer&));
   MOCK_METHOD1(OnDecodedFrame, bool(const MediaCodecLoop::OutputBuffer&));
   MOCK_METHOD0(OnOutputFormatChanged, bool());
   MOCK_METHOD0(OnCodecLoopError, void());
 };
 
 class MediaCodecLoopTest : public testing::Test {
  public:
   MediaCodecLoopTest()
-      : client_(new StrictMock<MockMediaCodecLoopClient>()),
-        task_runner_(new FakeSingleThreadTaskRunner(&clock_)) {}
+      : task_runner_handle_(mock_task_runner_),
+        client_(new StrictMock<MockMediaCodecLoopClient>()) {}
 
   ~MediaCodecLoopTest() override {}
 
  protected:
   enum IdleExpectation {
     ShouldBeIdle,
     ShouldNotBeIdle,
   };
 
   // Wait until |codec_loop_| is idle.
@@ skipping 16 matching lines @@
         break;
     }
 
     // Either way, we expect that MCL should not attempt to dequeue input
     // buffers, either because it's idle or because we said that no input
     // is pending.
     EXPECT_CALL(Codec(), DequeueInputBuffer(_, _)).Times(0);
 
     // TODO(liberato): assume that MCL doesn't retry for 30 seconds.  Note
     // that this doesn't actually wall-clock wait.
-    task_runner_->Sleep(base::TimeDelta::FromSeconds(30));
+    mock_task_runner_->FastForwardBy(base::TimeDelta::FromSeconds(30));
   }
 
   void ConstructCodecLoop(int sdk_int = kLollipop) {
     std::unique_ptr<MediaCodecBridge> codec(new MockMediaCodecBridge());
     // Since we're providing a codec, we do not expect an error.
     EXPECT_CALL(*client_, OnCodecLoopError()).Times(0);
     codec_loop_.reset(new MediaCodecLoop(sdk_int, client_.get(),
-                                         std::move(codec), task_runner_));
-    codec_loop_->SetTestTickClock(&clock_);
+                                         std::move(codec), mock_task_runner_));
+    codec_loop_->SetTestTickClock(clock_.get());
     Mock::VerifyAndClearExpectations(client_.get());
   }
 
   // Set an expectation that MCL will try to get another input / output buffer,
   // and not get one in DoPendingWork.
   void ExpectEmptyIOLoop() {
     ExpectIsAnyInputPending(false);
     EXPECT_CALL(Codec(), DequeueOutputBuffer(_, _, _, _, _, _, _))
         .Times(1)
         .WillOnce(Return(MEDIA_CODEC_TRY_AGAIN_LATER));
@@ skipping 68 matching lines @@
                     Field(&MediaCodecLoop::OutputBuffer::index, Eq(buf.index))))
         .Times(1)
         .WillOnce(Return(true));
   }
 
   MockMediaCodecBridge& Codec() {
     return *static_cast<MockMediaCodecBridge*>(codec_loop_->GetCodec());
   }
 
  public:
+  // Mocks the current thread's task runner which will also be used as the
+  // MediaCodecLoop's task runner.
+  scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_ =
+      new base::TestMockTimeTaskRunner;
+  base::ThreadTaskRunnerHandle task_runner_handle_;
+
+  // A reference to |mock_task_runner_|'s TickClock handed to |codec_loop_|.
+  std::unique_ptr<base::TickClock> clock_ =
+      mock_task_runner_->GetMockTickClock();
+
   std::unique_ptr<MediaCodecLoop> codec_loop_;
   std::unique_ptr<MockMediaCodecLoopClient> client_;
-  // TODO: how is the lifecycle of |clock_| handled?  |task_runner_| can outlive
-  // us, since it's a refptr.
-  base::SimpleTestTickClock clock_;
-  scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecLoopTest);
 };
 
 TEST_F(MediaCodecLoopTest, TestConstructionWithNullCodec) {
   std::unique_ptr<MediaCodecBridge> codec;
   EXPECT_CALL(*client_, OnCodecLoopError()).Times(1);
   const int sdk_int = kLollipop;
   codec_loop_.reset(
-      new MediaCodecLoop(sdk_int, client_.get(), std::move(codec)));
+      new MediaCodecLoop(sdk_int, client_.get(), std::move(codec),
+                         scoped_refptr<base::SingleThreadTaskRunner>()));
   // Do not WaitUntilIdle() here, since that assumes that we have a codec.
 
   ASSERT_FALSE(codec_loop_->GetCodec());
 }
 
 TEST_F(MediaCodecLoopTest, TestConstructionWithCodec) {
   ConstructCodecLoop();
   ASSERT_EQ(codec_loop_->GetCodec(), &Codec());
   WaitUntilIdle(ShouldBeIdle);
 }
@@ skipping 246 matching lines @@
 
     // MCL did work, so it will try again.
     ExpectEmptyIOLoop();
   }
 
   codec_loop_->OnKeyAdded();
   WaitUntilIdle(ShouldNotBeIdle);
 }
 
 }  // namespace media