Migrate media/blink/ off of ThreadTaskRunnerHandle::Get()

This is a precursor CL before moving media/blink/ to Blink, where the
usage of ThreadTaskRunnerHandle::Get() is banned.

This CL changes most classes to take a task runner parameter which is
properly selected at the call sites. In the case of unittests, the task
runner is provided by BlinkPlatformWithTaskEnvironment, which is the
class in charge of setting up Blink and the TaskEnvironment for the
tests.

Bug: 1198361
Change-Id: Ic98eaa01b31ee46289679869a6ff26ed1df93b09
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2896318
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Will Cassella <cassew@google.com>
Cr-Commit-Position: refs/heads/master@{#886483}

content/renderer/media/media_factory.cc

@@ -489,7 +489,9 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
   if (!fetch_context_) {
     fetch_context_ = std::make_unique<FrameFetchContext>(web_frame);
     DCHECK(!url_index_);
-    url_index_ = std::make_unique<media::UrlIndex>(fetch_context_.get());
+    url_index_ = std::make_unique<media::UrlIndex>(
+        fetch_context_.get(),
+        render_frame_->GetTaskRunner(blink::TaskType::kInternalMedia));
   }
   DCHECK_EQ(static_cast<FrameFetchContext*>(fetch_context_.get())->frame(),
             web_frame);

media/blink/multibuffer.cc

@@ -52,11 +52,11 @@ static MultiBuffer::BlockId ClosestNextEntry(
 // MultiBuffer::GlobalLRU
 //
 MultiBuffer::GlobalLRU::GlobalLRU(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : max_size_(0),
       data_size_(0),
       background_pruning_pending_(false),
-      task_runner_(task_runner) {}
+      task_runner_(std::move(task_runner)) {}
 
 MultiBuffer::GlobalLRU::~GlobalLRU() {
   // By the time we're freed, all blocks should have been removed,

media/blink/multibuffer.h

@@ -138,8 +138,7 @@ class MEDIA_BLINK_EXPORT MultiBuffer {
   class MEDIA_BLINK_EXPORT GlobalLRU : public base::RefCounted<GlobalLRU> {
    public:
     typedef MultiBufferGlobalBlockId GlobalBlockId;
-    explicit GlobalLRU(
-        const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+    explicit GlobalLRU(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
     // Free elements from cache if possible.
     // Don't free more than |max_to_free| blocks.

media/blink/multibuffer_data_source.cc

@@ -168,8 +168,8 @@ void MultibufferDataSource::CreateResourceLoader(int64_t first_byte_position,
 
   SetReader(new MultiBufferReader(
       url_data_->multibuffer(), first_byte_position, last_byte_position,
-      base::BindRepeating(&MultibufferDataSource::ProgressCallback,
-                          weak_ptr_)));
+      base::BindRepeating(&MultibufferDataSource::ProgressCallback, weak_ptr_),
+      render_task_runner_));
   reader_->SetIsClientAudioElement(is_client_audio_element_);
   UpdateBufferSizes();
 }
@@ -182,7 +182,8 @@ void MultibufferDataSource::CreateResourceLoader_Locked(
 
   reader_ = std::make_unique<MultiBufferReader>(
       url_data_->multibuffer(), first_byte_position, last_byte_position,
-      base::BindRepeating(&MultibufferDataSource::ProgressCallback, weak_ptr_));
+      base::BindRepeating(&MultibufferDataSource::ProgressCallback, weak_ptr_),
+      render_task_runner_);
   UpdateBufferSizes();
 }
 

media/blink/multibuffer_data_source_unittest.cc

@@ -6,15 +6,20 @@
 #include <stdint.h>
 
 #include <memory>
+#include <utility>
 
 #include "base/bind.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/task_environment.h"
 #include "media/base/media_switches.h"
 #include "media/base/media_util.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "media/blink/buffered_data_source_host_impl.h"
 #include "media/blink/mock_resource_fetch_context.h"
 #include "media/blink/mock_webassociatedurlloader.h"
@@ -48,10 +53,14 @@ std::set<TestMultiBufferDataProvider*> test_data_providers;
 
 class TestMultiBufferDataProvider : public ResourceMultiBufferDataProvider {
  public:
-  TestMultiBufferDataProvider(UrlData* url_data, MultiBuffer::BlockId pos)
+  TestMultiBufferDataProvider(
+      UrlData* url_data,
+      MultiBuffer::BlockId pos,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : ResourceMultiBufferDataProvider(url_data,
                                         pos,
-                                        false /* is_client_audio_element */) {
+                                        false /* is_client_audio_element */,
+                                        std::move(task_runner)) {
     CHECK(test_data_providers.insert(this).second);
   }
   ~TestMultiBufferDataProvider() override {
@@ -82,12 +91,17 @@ class TestUrlData;
 
 class TestResourceMultiBuffer : public ResourceMultiBuffer {
  public:
-  explicit TestResourceMultiBuffer(UrlData* url_data, int shift)
-      : ResourceMultiBuffer(url_data, shift) {}
+  TestResourceMultiBuffer(
+      UrlData* url_data,
+      int shift,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : ResourceMultiBuffer(url_data, shift, task_runner),
+        task_runner_(std::move(task_runner)) {}
 
   std::unique_ptr<MultiBuffer::DataProvider> CreateWriter(const BlockId& pos,
                                                           bool) override {
-    auto writer = std::make_unique<TestMultiBufferDataProvider>(url_data_, pos);
+    auto writer = std::make_unique<TestMultiBufferDataProvider>(url_data_, pos,
+                                                                task_runner_);
     writer->Start();
     return writer;
   }
@@ -112,45 +126,55 @@ class TestResourceMultiBuffer : public ResourceMultiBuffer {
       return false;
     return GetProvider()->loading();
   }
+
+ private:
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 class TestUrlData : public UrlData {
  public:
-  TestUrlData(const GURL& url, CorsMode cors_mode, UrlIndex* url_index)
-      : UrlData(url, cors_mode, url_index),
-        block_shift_(url_index->block_shift()) {}
+  TestUrlData(const GURL& url,
+              CorsMode cors_mode,
+              UrlIndex* url_index,
+              scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : UrlData(url, cors_mode, url_index, task_runner),
+        block_shift_(url_index->block_shift()),
+        task_runner_(std::move(task_runner)) {}
 
   ResourceMultiBuffer* multibuffer() override {
     if (!test_multibuffer_.get()) {
-      test_multibuffer_ =
-          std::make_unique<TestResourceMultiBuffer>(this, block_shift_);
+      test_multibuffer_ = std::make_unique<TestResourceMultiBuffer>(
+          this, block_shift_, task_runner_);
     }
     return test_multibuffer_.get();
   }
 
   TestResourceMultiBuffer* test_multibuffer() {
     if (!test_multibuffer_.get()) {
-      test_multibuffer_ =
-          std::make_unique<TestResourceMultiBuffer>(this, block_shift_);
+      test_multibuffer_ = std::make_unique<TestResourceMultiBuffer>(
+          this, block_shift_, task_runner_);
     }
     return test_multibuffer_.get();
   }
 
- protected:
+ private:
   ~TestUrlData() override = default;
-  const int block_shift_;
 
+  const int block_shift_;
   std::unique_ptr<TestResourceMultiBuffer> test_multibuffer_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 class TestUrlIndex : public UrlIndex {
  public:
-  explicit TestUrlIndex(ResourceFetchContext* fetch_context)
-      : UrlIndex(fetch_context) {}
+  TestUrlIndex(ResourceFetchContext* fetch_context,
+               scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : UrlIndex(fetch_context, task_runner),
+        task_runner_(std::move(task_runner)) {}
 
   scoped_refptr<UrlData> NewUrlData(const GURL& url,
                                     UrlData::CorsMode cors_mode) override {
-    last_url_data_ = new TestUrlData(url, cors_mode, this);
+    last_url_data_ = new TestUrlData(url, cors_mode, this, task_runner_);
     return last_url_data_;
   }
 
@@ -163,6 +187,7 @@ class TestUrlIndex : public UrlIndex {
 
  private:
   scoped_refptr<TestUrlData> last_url_data_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 class MockBufferedDataSourceHost : public BufferedDataSourceHost {
@@ -221,8 +246,6 @@ class MultibufferDataSourceTest : public testing::Test {
         .WillByDefault(Invoke([](const blink::WebAssociatedURLLoaderOptions&) {
           return std::make_unique<NiceMock<MockWebAssociatedURLLoader>>();
         }));
-
-    url_index_ = std::make_unique<TestUrlIndex>(&fetch_context_);
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
@@ -233,8 +256,8 @@ class MultibufferDataSourceTest : public testing::Test {
                           size_t file_size = kFileSize) {
     GURL gurl(url);
     data_source_ = std::make_unique<MockMultibufferDataSource>(
-        base::ThreadTaskRunnerHandle::Get(),
-        url_index_->GetByUrl(gurl, cors_mode, UrlIndex::kNormal), &host_);
+        task_runner_, url_index_.GetByUrl(gurl, cors_mode, UrlIndex::kNormal),
+        &host_);
     data_source_->SetPreload(preload_);
 
     response_generator_ =
@@ -410,7 +433,7 @@ class MultibufferDataSourceTest : public testing::Test {
   MultiBufferReader* loader() { return data_source_->reader_.get(); }
 
   TestResourceMultiBuffer* multibuffer() {
-    return url_index_->last_url_data()->test_multibuffer();
+    return url_index_.last_url_data()->test_multibuffer();
   }
 
   TestMultiBufferDataProvider* data_provider() {
@@ -459,7 +482,10 @@ class MultibufferDataSourceTest : public testing::Test {
  protected:
   MultibufferDataSource::Preload preload_;
   NiceMock<MockResourceFetchContext> fetch_context_;
-  std::unique_ptr<TestUrlIndex> url_index_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_ =
+      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment()
+          ->GetMainThreadTaskRunner();
+  TestUrlIndex url_index_{&fetch_context_, task_runner_};
 
   std::unique_ptr<MockMultibufferDataSource> data_source_;
 
@@ -996,9 +1022,9 @@ TEST_F(MultibufferDataSourceTest, Http_ShareData) {
 
   StrictMock<MockBufferedDataSourceHost> host2;
   MockMultibufferDataSource source2(
-      base::ThreadTaskRunnerHandle::Get(),
-      url_index_->GetByUrl(GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
-                           UrlIndex::kNormal),
+      task_runner_,
+      url_index_.GetByUrl(GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED,
+                          UrlIndex::kNormal),
       &host2);
   source2.SetPreload(preload_);
 
@@ -1363,8 +1389,8 @@ TEST_F(MultibufferDataSourceTest,
 TEST_F(MultibufferDataSourceTest, SeekPastEOF) {
   GURL gurl(kHttpUrl);
   data_source_ = std::make_unique<MockMultibufferDataSource>(
-      base::ThreadTaskRunnerHandle::Get(),
-      url_index_->GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlIndex::kNormal),
+      task_runner_,
+      url_index_.GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlIndex::kNormal),
       &host_);
   data_source_->SetPreload(preload_);
 
@@ -1742,8 +1768,8 @@ TEST_F(MultibufferDataSourceTest, CheckBufferSizeAfterReadingALot) {
 TEST_F(MultibufferDataSourceTest, Http_CheckLoadingTransition) {
   GURL gurl(kHttpUrl);
   data_source_ = std::make_unique<MockMultibufferDataSource>(
-      base::ThreadTaskRunnerHandle::Get(),
-      url_index_->GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlIndex::kNormal),
+      task_runner_,
+      url_index_.GetByUrl(gurl, UrlData::CORS_UNSPECIFIED, UrlIndex::kNormal),
       &host_);
   data_source_->SetPreload(preload_);
 

media/blink/multibuffer_reader.cc

@@ -4,11 +4,12 @@
 
 #include <stddef.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "media/blink/multibuffer_reader.h"
 #include "net/base/net_errors.h"
 
@@ -18,7 +19,8 @@ MultiBufferReader::MultiBufferReader(
     MultiBuffer* multibuffer,
     int64_t start,
     int64_t end,
-    base::RepeatingCallback<void(int64_t, int64_t)> progress_callback)
+    base::RepeatingCallback<void(int64_t, int64_t)> progress_callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : multibuffer_(multibuffer),
       // If end is -1, we use a very large (but still supported) value instead.
       end_(end == -1LL ? (1LL << (multibuffer->block_size_shift() + 30)) : end),
@@ -32,7 +34,8 @@ MultiBufferReader::MultiBufferReader(
       preload_pos_(-1),
       loading_(true),
       current_wait_size_(0),
-      progress_callback_(std::move(progress_callback)) {
+      progress_callback_(std::move(progress_callback)),
+      task_runner_(std::move(task_runner)) {
   DCHECK_GE(start, 0);
   DCHECK_GE(end_, 0);
 }
@@ -149,7 +152,7 @@ void MultiBufferReader::CheckWait() {
     // We redirect the call through a weak pointer to ourselves to guarantee
     // there are no callbacks from us after we've been destroyed.
     current_wait_size_ = 0;
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
+    task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&MultiBufferReader::Call,
                                   weak_factory_.GetWeakPtr(), std::move(cb_)));
   }
@@ -178,7 +181,7 @@ void MultiBufferReader::NotifyAvailableRange(
   }
   UpdateInternalState();
   if (!progress_callback_.is_null()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
+    task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(progress_callback_,
                        static_cast<int64_t>(range.begin)

media/blink/multibuffer_reader.h

@@ -8,10 +8,15 @@
 #include <stdint.h>
 
 #include "base/callback.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/multibuffer.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace media {
 
 // Wrapper for MultiBuffer that offers a simple byte-reading
@@ -34,7 +39,8 @@ class MEDIA_BLINK_EXPORT MultiBufferReader : public MultiBuffer::Reader {
       MultiBuffer* multibuffer,
       int64_t start,
       int64_t end,
-      base::RepeatingCallback<void(int64_t, int64_t)> progress_callback);
+      base::RepeatingCallback<void(int64_t, int64_t)> progress_callback,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   ~MultiBufferReader() override;
 
@@ -180,6 +186,8 @@ class MEDIA_BLINK_EXPORT MultiBufferReader : public MultiBuffer::Reader {
   // Progress callback.
   base::RepeatingCallback<void(int64_t, int64_t)> progress_callback_;
 
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
   base::WeakPtrFactory<MultiBufferReader> weak_factory_{this};
 };
 

media/blink/multibuffer_unittest.cc

@@ -6,12 +6,14 @@
 #include <stdint.h>
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/containers/circular_deque.h"
 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/test_random.h"
@@ -262,7 +264,8 @@ TEST_F(MultiBufferTest, ReadAll) {
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
@@ -289,7 +292,8 @@ TEST_F(MultiBufferTest, ReadAllAdvanceFirst) {
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
@@ -318,7 +322,8 @@ TEST_F(MultiBufferTest, ReadAllAdvanceFirst_NeverDefer) {
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMaxBlocksAfterDefer(-10000);
   multibuffer_.SetRangeSupported(true);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
@@ -348,7 +353,8 @@ TEST_F(MultiBufferTest, ReadAllAdvanceFirst_NeverDefer2) {
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
   multibuffer_.SetMaxBlocksAfterDefer(-10000);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
@@ -377,7 +383,8 @@ TEST_F(MultiBufferTest, LRUTest) {
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPreload(10000, 10000);
   // Note, no pinning, all data should end up in LRU.
   EXPECT_EQ(current_size, lru_->Size());
@@ -405,7 +412,8 @@ TEST_F(MultiBufferTest, LRUTest2) {
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPreload(10000, 10000);
   // Note, no pinning, all data should end up in LRU.
   EXPECT_EQ(current_size, lru_->Size());
@@ -434,7 +442,8 @@ TEST_F(MultiBufferTest, LRUTestExpirationTest) {
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
-  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback());
+  MultiBufferReader reader(&multibuffer_, pos, end, base::NullCallback(),
+                           task_runner_);
   reader.SetPreload(10000, 10000);
   // Note, no pinning, all data should end up in LRU.
   EXPECT_EQ(current_size, lru_->Size());
@@ -473,13 +482,18 @@ class ReadHelper {
   ReadHelper(size_t end,
              size_t max_read_size,
              MultiBuffer* multibuffer,
-             TestRandom* rnd)
+             TestRandom* rnd,
+             scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : pos_(0),
         end_(end),
         max_read_size_(max_read_size),
         read_size_(0),
         rnd_(rnd),
-        reader_(multibuffer, pos_, end_, base::NullCallback()) {
+        reader_(multibuffer,
+                pos_,
+                end_,
+                base::NullCallback(),
+                std::move(task_runner)) {
     reader_.SetPinRange(2000, 5000);
     reader_.SetPreload(1000, 1000);
   }
@@ -536,7 +550,7 @@ TEST_F(MultiBufferTest, RandomTest) {
   std::vector<ReadHelper*> read_helpers;
   for (size_t i = 0; i < 20; i++) {
     read_helpers.push_back(
-        new ReadHelper(file_size, 1000, &multibuffer_, &rnd_));
+        new ReadHelper(file_size, 1000, &multibuffer_, &rnd_, task_runner_));
   }
   for (int i = 0; i < 100; i++) {
     for (int j = 0; j < 100; j++) {
@@ -567,7 +581,7 @@ TEST_F(MultiBufferTest, RandomTest_RangeSupported) {
   multibuffer_.SetRangeSupported(true);
   for (size_t i = 0; i < 20; i++) {
     read_helpers.push_back(
-        new ReadHelper(file_size, 1000, &multibuffer_, &rnd_));
+        new ReadHelper(file_size, 1000, &multibuffer_, &rnd_, task_runner_));
   }
   for (int i = 0; i < 100; i++) {
     for (int j = 0; j < 100; j++) {

media/blink/resource_multibuffer_data_provider.cc

@@ -15,7 +15,6 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "media/blink/cache_util.h"
 #include "media/blink/resource_fetch_context.h"
 #include "media/blink/url_index.h"
@@ -58,13 +57,15 @@ const int kHttpRangeNotSatisfiable = 416;
 ResourceMultiBufferDataProvider::ResourceMultiBufferDataProvider(
     UrlData* url_data,
     MultiBufferBlockId pos,
-    bool is_client_audio_element)
+    bool is_client_audio_element,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : pos_(pos),
       url_data_(url_data),
       retries_(0),
       cors_mode_(url_data->cors_mode()),
       origin_(url_data->url().GetOrigin()),
-      is_client_audio_element_(is_client_audio_element) {
+      is_client_audio_element_(is_client_audio_element),
+      task_runner_(std::move(task_runner)) {
   DCHECK(url_data_) << " pos = " << pos;
   DCHECK_GE(pos, 0);
 }
@@ -74,7 +75,7 @@ ResourceMultiBufferDataProvider::~ResourceMultiBufferDataProvider() = default;
 void ResourceMultiBufferDataProvider::Start() {
   DVLOG(1) << __func__ << " @ " << byte_pos();
   if (url_data_->length() > 0 && byte_pos() >= url_data_->length()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
+    task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&ResourceMultiBufferDataProvider::Terminate,
                                   weak_factory_.GetWeakPtr()));
     return;
@@ -444,7 +445,7 @@ void ResourceMultiBufferDataProvider::DidFinishLoading() {
     if (retries_ < kMaxRetries) {
       DVLOG(1) << " Partial data received.... @ pos = " << size;
       retries_++;
-      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      task_runner_->PostDelayedTask(
           FROM_HERE,
           base::BindOnce(&ResourceMultiBufferDataProvider::Start,
                          weak_factory_.GetWeakPtr()),
@@ -476,7 +477,7 @@ void ResourceMultiBufferDataProvider::DidFail(const WebURLError& error) {
 
   if (retries_ < kMaxRetries && pos_ != 0) {
     retries_++;
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+    task_runner_->PostDelayedTask(
         FROM_HERE,
         base::BindOnce(&ResourceMultiBufferDataProvider::Start,
                        weak_factory_.GetWeakPtr()),

media/blink/resource_multibuffer_data_provider.h

@@ -11,6 +11,7 @@
 #include <string>
 
 #include "base/callback.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/multibuffer.h"
@@ -20,6 +21,10 @@
 #include "third_party/blink/public/web/web_frame.h"
 #include "url/gurl.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace blink {
 class WebAssociatedURLLoader;
 }  // namespace blink
@@ -33,9 +38,11 @@ class MEDIA_BLINK_EXPORT ResourceMultiBufferDataProvider
   // NUmber of times we'll retry if the connection fails.
   enum { kMaxRetries = 30 };
 
-  ResourceMultiBufferDataProvider(UrlData* url_data,
-                                  MultiBufferBlockId pos,
-                                  bool is_client_audio_element);
+  ResourceMultiBufferDataProvider(
+      UrlData* url_data,
+      MultiBufferBlockId pos,
+      bool is_client_audio_element,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~ResourceMultiBufferDataProvider() override;
 
   // Virtual for testing purposes.
@@ -123,6 +130,8 @@ class MEDIA_BLINK_EXPORT ResourceMultiBufferDataProvider
   // Is the client an audio element?
   bool is_client_audio_element_ = false;
 
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
   base::WeakPtrFactory<ResourceMultiBufferDataProvider> weak_factory_{this};
 };
 

media/blink/resource_multibuffer_data_provider_unittest.cc

@@ -12,10 +12,14 @@
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/task_environment.h"
 #include "media/base/media_log.h"
 #include "media/base/seekable_buffer.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "media/blink/mock_resource_fetch_context.h"
 #include "media/blink/mock_webassociatedurlloader.h"
 #include "media/blink/url_index.h"
@@ -76,8 +80,7 @@ static bool CorrectAcceptEncodingAndPreviewsState(
 
 class ResourceMultiBufferDataProviderTest : public testing::Test {
  public:
-  ResourceMultiBufferDataProviderTest()
-      : url_index_(std::make_unique<UrlIndex>(&fetch_context_, 0)) {
+  ResourceMultiBufferDataProviderTest() {
     for (int i = 0; i < kDataSize; ++i) {
       data_[i] = i;
     }
@@ -89,8 +92,8 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
   void Initialize(const char* url, int first_position) {
     want_frfr = false;
     gurl_ = GURL(url);
-    url_data_ = url_index_->GetByUrl(gurl_, UrlData::CORS_UNSPECIFIED,
-                                     UrlIndex::kNormal);
+    url_data_ = url_index_.GetByUrl(gurl_, UrlData::CORS_UNSPECIFIED,
+                                    UrlIndex::kNormal);
     url_data_->set_etag(kEtag);
     DCHECK(url_data_);
     url_data_->OnRedirect(
@@ -102,7 +105,9 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
     std::unique_ptr<ResourceMultiBufferDataProvider> loader(
         new ResourceMultiBufferDataProvider(
             url_data_.get(), first_position_,
-            false /* is_client_audio_element */));
+            false /* is_client_audio_element */,
+            BlinkPlatformWithTaskEnvironment::GetTaskEnvironment()
+                ->GetMainThreadTaskRunner()));
     loader_ = loader.get();
     url_data_->multibuffer()->AddProvider(std::move(loader));
   }
@@ -222,7 +227,9 @@ class ResourceMultiBufferDataProviderTest : public testing::Test {
   int64_t first_position_;
 
   NiceMock<MockResourceFetchContext> fetch_context_;
-  std::unique_ptr<UrlIndex> url_index_;
+  UrlIndex url_index_{&fetch_context_, 0,
+                      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment()
+                          ->GetMainThreadTaskRunner()};
   scoped_refptr<UrlData> url_data_;
   scoped_refptr<UrlData> redirected_to_;
   // The loader is owned by the UrlData above.

media/blink/url_index.cc

@@ -11,7 +11,6 @@
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/base/media_switches.h"
 #include "media/blink/resource_multibuffer_data_provider.h"
@@ -21,9 +20,13 @@ namespace media {
 const int kBlockSizeShift = 15;  // 1<<15 == 32kb
 const int kUrlMappingTimeoutSeconds = 300;
 
-ResourceMultiBuffer::ResourceMultiBuffer(UrlData* url_data, int block_shift)
+ResourceMultiBuffer::ResourceMultiBuffer(
+    UrlData* url_data,
+    int block_shift,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : MultiBuffer(block_shift, url_data->url_index_->lru_),
-      url_data_(url_data) {}
+      url_data_(url_data),
+      task_runner_(std::move(task_runner)) {}
 
 ResourceMultiBuffer::~ResourceMultiBuffer() = default;
 
@@ -31,7 +34,7 @@ std::unique_ptr<MultiBuffer::DataProvider> ResourceMultiBuffer::CreateWriter(
     const MultiBufferBlockId& pos,
     bool is_client_audio_element) {
   auto writer = std::make_unique<ResourceMultiBufferDataProvider>(
-      url_data_, pos, is_client_audio_element);
+      url_data_, pos, is_client_audio_element, task_runner_);
   writer->Start();
   return writer;
 }
@@ -44,7 +47,10 @@ void ResourceMultiBuffer::OnEmpty() {
   url_data_->OnEmpty();
 }
 
-UrlData::UrlData(const GURL& url, CorsMode cors_mode, UrlIndex* url_index)
+UrlData::UrlData(const GURL& url,
+                 CorsMode cors_mode,
+                 UrlIndex* url_index,
+                 scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : url_(url),
       have_data_origin_(false),
       cors_mode_(cors_mode),
@@ -53,8 +59,7 @@ UrlData::UrlData(const GURL& url, CorsMode cors_mode, UrlIndex* url_index)
       length_(kPositionNotSpecified),
       range_supported_(false),
       cacheable_(false),
-      last_used_(),
-      multibuffer_(this, url_index_->block_shift_) {}
+      multibuffer_(this, url_index_->block_shift_, std::move(task_runner)) {}
 
 UrlData::~UrlData() = default;
 
@@ -210,16 +215,20 @@ size_t UrlData::CachedSize() {
   return multibuffer()->map().size();
 }
 
-UrlIndex::UrlIndex(ResourceFetchContext* fetch_context)
-    : UrlIndex(fetch_context, kBlockSizeShift) {}
+UrlIndex::UrlIndex(ResourceFetchContext* fetch_context,
+                   scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : UrlIndex(fetch_context, kBlockSizeShift, std::move(task_runner)) {}
 
-UrlIndex::UrlIndex(ResourceFetchContext* fetch_context, int block_shift)
+UrlIndex::UrlIndex(ResourceFetchContext* fetch_context,
+                   int block_shift,
+                   scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : fetch_context_(fetch_context),
-      lru_(new MultiBuffer::GlobalLRU(base::ThreadTaskRunnerHandle::Get())),
+      lru_(new MultiBuffer::GlobalLRU(task_runner)),
       block_shift_(block_shift),
       memory_pressure_listener_(FROM_HERE,
                                 base::BindRepeating(&UrlIndex::OnMemoryPressure,
-                                                    base::Unretained(this))) {}
+                                                    base::Unretained(this))),
+      task_runner_(std::move(task_runner)) {}
 
 UrlIndex::~UrlIndex() {
 #if DCHECK_IS_ON()
@@ -254,7 +263,7 @@ scoped_refptr<UrlData> UrlIndex::GetByUrl(const GURL& gurl,
 
 scoped_refptr<UrlData> UrlIndex::NewUrlData(const GURL& url,
                                             UrlData::CorsMode cors_mode) {
-  return new UrlData(url, cors_mode, this);
+  return new UrlData(url, cors_mode, this, task_runner_);
 }
 
 void UrlIndex::OnMemoryPressure(

media/blink/url_index.h

@@ -14,12 +14,17 @@
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/multibuffer.h"
 #include "url/gurl.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace media {
 
 const int64_t kPositionNotSpecified = -1;
@@ -33,7 +38,9 @@ class UrlIndexTest;
 // into the cache.
 class MEDIA_BLINK_EXPORT ResourceMultiBuffer : public MultiBuffer {
  public:
-  ResourceMultiBuffer(UrlData* url_data_, int block_shift);
+  ResourceMultiBuffer(UrlData* url_data_,
+                      int block_shift,
+                      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~ResourceMultiBuffer() override;
 
   // MultiBuffer implementation.
@@ -47,6 +54,7 @@ class MEDIA_BLINK_EXPORT ResourceMultiBuffer : public MultiBuffer {
   // Do not access from destructor, it is a pointer to the
   // object that contains us.
   UrlData* url_data_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 class UrlIndex;
@@ -151,7 +159,10 @@ class MEDIA_BLINK_EXPORT UrlData : public base::RefCounted<UrlData> {
   int64_t BytesReadFromCache() const { return bytes_read_from_cache_; }
 
  protected:
-  UrlData(const GURL& url, CorsMode cors_mode, UrlIndex* url_index);
+  UrlData(const GURL& url,
+          CorsMode cors_mode,
+          UrlIndex* url_index,
+          scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   virtual ~UrlData();
 
  private:
@@ -222,8 +233,11 @@ class MEDIA_BLINK_EXPORT UrlData : public base::RefCounted<UrlData> {
 // The UrlIndex lets you look up UrlData instances by url.
 class MEDIA_BLINK_EXPORT UrlIndex {
  public:
-  explicit UrlIndex(ResourceFetchContext* fetch_context);
-  UrlIndex(ResourceFetchContext* fetch_context, int block_shift);
+  UrlIndex(ResourceFetchContext* fetch_context,
+           scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  UrlIndex(ResourceFetchContext* fetch_context,
+           int block_shift,
+           scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   virtual ~UrlIndex();
 
   enum CacheMode { kNormal, kCacheDisabled };
@@ -288,6 +302,7 @@ class MEDIA_BLINK_EXPORT UrlIndex {
   std::deque<scoped_refptr<UrlData>> loading_queue_;
 
   base::MemoryPressureListener memory_pressure_listener_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 }  // namespace media

media/blink/url_index_unittest.cc

@@ -7,9 +7,13 @@
 #include <list>
 #include <string>
 
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/task_environment.h"
 #include "media/base/media_switches.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "media/blink/url_index.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -17,7 +21,7 @@ namespace media {
 
 class UrlIndexTest : public testing::Test {
  public:
-  UrlIndexTest() : url_index_(nullptr) {}
+  UrlIndexTest() = default;
 
   scoped_refptr<UrlData> GetByUrl(const GURL& gurl,
                                   UrlData::CorsMode cors_mode) {
@@ -28,7 +32,10 @@ class UrlIndexTest : public testing::Test {
     return ret;
   }
 
-  UrlIndex url_index_;
+ protected:
+  UrlIndex url_index_{nullptr,
+                      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment()
+                          ->GetMainThreadTaskRunner()};
 };
 
 TEST_F(UrlIndexTest, SimpleTest) {

media/blink/video_decode_stats_reporter_unittest.cc

@@ -7,15 +7,15 @@
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/single_thread_task_runner.h"
-#include "base/task/current_thread.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/test/task_environment.h"
 #include "base/time/time.h"
 #include "media/base/cdm_config.h"
 #include "media/base/media_util.h"
 #include "media/base/video_codecs.h"
 #include "media/base/video_types.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "media/blink/video_decode_stats_reporter.h"
 #include "media/capabilities/bucket_utility.h"
 #include "media/mojo/mojom/media_types.mojom.h"
@@ -108,12 +108,6 @@ class VideoDecodeStatsReporterTest : public ::testing::Test {
   ~VideoDecodeStatsReporterTest() override = default;
 
   void SetUp() override {
-    // Do this first. Lots of pieces depend on the task runner.
-    auto message_loop = base::CurrentThread::Get();
-    original_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    task_runner_ = new base::TestMockTimeTaskRunner();
-    message_loop.SetTaskRunner(task_runner_);
-
     // Make reporter with default configuration. Connects RecordInterceptor as
     // remote mojo VideoDecodeStatsRecorder.
     MakeReporter();
@@ -130,8 +124,7 @@ class VideoDecodeStatsReporterTest : public ::testing::Test {
     reporter_.reset();
 
     // Run task runner to have Mojo cleanup interceptor_.
-    task_runner_->RunUntilIdle();
-    base::CurrentThread::Get().SetTaskRunner(original_task_runner_);
+    task_environment_->RunUntilIdle();
   }
 
   PipelineStatistics MakeAdvancingDecodeStats() {
@@ -191,13 +184,14 @@ class VideoDecodeStatsReporterTest : public ::testing::Test {
         SetupRecordInterceptor(&interceptor_),
         base::BindRepeating(&VideoDecodeStatsReporterTest::GetPipelineStatsCB,
                             base::Unretained(this)),
-        profile, natural_size, key_system, cdm_config, task_runner_,
-        task_runner_->GetMockTickClock());
+        profile, natural_size, key_system, cdm_config,
+        task_environment_->GetMainThreadTaskRunner(),
+        task_environment_->GetMockTickClock());
   }
 
   // Fast forward the task runner (and associated tick clock) by |milliseconds|.
   void FastForward(base::TimeDelta delta) {
-    task_runner_->FastForwardBy(delta);
+    task_environment_->FastForwardBy(delta);
   }
 
   bool ShouldBeReporting() const { return reporter_->ShouldBeReporting(); }
@@ -351,6 +345,9 @@ class VideoDecodeStatsReporterTest : public ::testing::Test {
   // expectations and return behavior.
   MOCK_METHOD0(GetPipelineStatsCB, PipelineStatistics());
 
+  base::test::TaskEnvironment* task_environment_ =
+      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment();
+
   // These track the last values returned by MakeAdvancingDecodeStats(). See
   // SetUp() for initialization.
   uint32_t pipeline_decoded_frames_;
@@ -361,12 +358,6 @@ class VideoDecodeStatsReporterTest : public ::testing::Test {
   // Placed as a class member to avoid static initialization costs.
   const gfx::Size kDefaultSize_;
 
-  // Task runner that allows for manual advancing of time. Instantiated during
-  // Setup(). |original_task_runner_| is a copy of the TaskRunner in place prior
-  // to the start of this test. It's restored after the test completes.
-  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> original_task_runner_;
-
   // Points to the interceptor that acts as a VideoDecodeStatsRecorder. The
   // object is owned by mojo::Remote<VideoDecodeStatsRecorder>, which is itself
   // owned by |reporter_|.

media/blink/video_frame_compositor_unittest.cc

@@ -5,14 +5,17 @@
 #include "media/blink/video_frame_compositor.h"
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/gmock_callback_support.h"
 #include "base/test/simple_test_tick_clock.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/test/task_environment.h"
 #include "components/viz/common/frame_sinks/begin_frame_args.h"
 #include "components/viz/common/surfaces/frame_sink_id.h"
 #include "media/base/video_frame.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/web_video_frame_submitter.h"
@@ -61,8 +64,8 @@ class VideoFrameCompositorTest : public VideoRendererSink::RenderCallback,
     submitter_ = client_.get();
 
     EXPECT_CALL(*submitter_, Initialize(_, _));
-    compositor_ = std::make_unique<VideoFrameCompositor>(
-        base::ThreadTaskRunnerHandle::Get(), std::move(client_));
+    compositor_ = std::make_unique<VideoFrameCompositor>(task_runner_,
+                                                         std::move(client_));
     base::RunLoop().RunUntilIdle();
     EXPECT_CALL(*submitter_,
                 SetRotation(Eq(media::VideoRotation::VIDEO_ROTATION_90)));
@@ -139,6 +142,9 @@ class VideoFrameCompositorTest : public VideoRendererSink::RenderCallback,
   StrictMock<MockWebVideoFrameSubmitter>* submitter_;
   std::unique_ptr<StrictMock<MockWebVideoFrameSubmitter>> client_;
   std::unique_ptr<VideoFrameCompositor> compositor_;
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_ =
+      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment()
+          ->GetMainThreadTaskRunner();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositorTest);
@@ -155,8 +161,7 @@ TEST_F(VideoFrameCompositorTest, SetIsSurfaceVisible) {
     base::RunLoop run_loop;
     EXPECT_CALL(*submitter_, SetIsSurfaceVisible(true));
     cb.Run(true, nullptr);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  run_loop.QuitClosure());
+    task_runner_->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
   }
 
@@ -164,8 +169,7 @@ TEST_F(VideoFrameCompositorTest, SetIsSurfaceVisible) {
     base::RunLoop run_loop;
     EXPECT_CALL(*submitter_, SetIsSurfaceVisible(false));
     cb.Run(false, nullptr);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  run_loop.QuitClosure());
+    task_runner_->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
   }
 
@@ -174,8 +178,7 @@ TEST_F(VideoFrameCompositorTest, SetIsSurfaceVisible) {
     base::WaitableEvent true_event;
     EXPECT_CALL(*submitter_, SetIsSurfaceVisible(true));
     cb.Run(true, &true_event);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  run_loop.QuitClosure());
+    task_runner_->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(true_event.IsSignaled());
   }
@@ -186,8 +189,7 @@ TEST_F(VideoFrameCompositorTest, SetIsSurfaceVisible) {
     EXPECT_CALL(*submitter_, SetIsSurfaceVisible(false));
     cb.Run(false, &false_event);
 
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  run_loop.QuitClosure());
+    task_runner_->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_TRUE(false_event.IsSignaled());
   }

media/blink/watch_time_reporter_unittest.cc

@@ -6,15 +6,15 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/task/current_thread.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/test/task_environment.h"
 #include "base/time/time.h"
 #include "media/base/mock_media_log.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/watch_time_keys.h"
+#include "media/blink/blink_platform_with_task_environment.h"
 #include "media/mojo/mojom/media_metrics_provider.mojom.h"
 #include "media/mojo/mojom/watch_time_recorder.mojom.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
@@ -290,18 +290,10 @@ class WatchTimeReporterTest
   WatchTimeReporterTest()
       : has_video_(std::get<0>(GetParam())),
         has_audio_(std::get<1>(GetParam())),
-        fake_metrics_provider_(this) {
-    // Do this first. Lots of pieces depend on the task runner.
-    auto message_loop = base::CurrentThread::Get();
-    original_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    task_runner_ = new base::TestMockTimeTaskRunner();
-    message_loop.SetTaskRunner(task_runner_);
-  }
+        fake_metrics_provider_(this) {}
 
   ~WatchTimeReporterTest() override {
     CycleReportingTimer();
-    task_runner_->RunUntilIdle();
-    base::CurrentThread::Get().SetTaskRunner(original_task_runner_);
   }
 
  protected:
@@ -322,7 +314,7 @@ class WatchTimeReporterTest
                             base::Unretained(this)),
         &fake_metrics_provider_,
         blink::scheduler::GetSequencedTaskRunnerForTesting(),
-        task_runner_->GetMockTickClock());
+        task_environment_->GetMockTickClock());
     reporting_interval_ = wtr_->reporting_interval_;
 
     // Most tests don't care about this.
@@ -333,7 +325,7 @@ class WatchTimeReporterTest
   }
 
   void CycleReportingTimer() {
-    task_runner_->FastForwardBy(reporting_interval_);
+    task_environment_->FastForwardBy(reporting_interval_);
   }
 
   bool IsMonitoring() const { return wtr_->reporting_timer_.IsRunning(); }
@@ -638,15 +630,11 @@ class WatchTimeReporterTest
   MOCK_METHOD2(OnUpdateVideoDecodeStats, void(uint32_t, uint32_t));
   MOCK_METHOD1(OnCurrentTimestampChanged, void(base::TimeDelta));
 
+  base::test::TaskEnvironment* task_environment_ =
+      BlinkPlatformWithTaskEnvironment::GetTaskEnvironment();
   const bool has_video_;
   const bool has_audio_;
 
-  // Task runner that allows for manual advancing of time. Instantiated during
-  // construction. |original_task_runner_| is a copy of the TaskRunner in place
-  // prior to the start of this test. It's restored after the test completes.
-  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> original_task_runner_;
-
   FakeMediaMetricsProvider fake_metrics_provider_;
   std::unique_ptr<blink::WatchTimeReporter> wtr_;
   base::TimeDelta reporting_interval_;

media/blink/webcontentdecryptionmoduleaccess_impl.cc

@@ -10,7 +10,6 @@
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "media/blink/webencryptedmediaclient_impl.h"
 
 namespace media {

media/blink/webmediaplayer_impl.cc

@@ -27,7 +27,6 @@
 #include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
 #include "base/task_runner_util.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"

media/blink/webmediaplayer_impl_unittest.cc

@@ -12,8 +12,10 @@
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ -24,7 +26,6 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "build/build_config.h"
 #include "cc/layers/layer.h"
@@ -424,12 +425,13 @@ class WebMediaPlayerImplTest
 
     audio_sink_ = base::WrapRefCounted(new NiceMock<MockAudioRendererSink>());
 
-    url_index_ = std::make_unique<UrlIndex>(&mock_resource_fetch_context_);
+    url_index_ = std::make_unique<UrlIndex>(&mock_resource_fetch_context_,
+                                            media_thread_.task_runner());
 
     auto params = std::make_unique<WebMediaPlayerParams>(
         std::move(media_log), WebMediaPlayerParams::DeferLoadCB(), audio_sink_,
-        media_thread_.task_runner(), base::ThreadTaskRunnerHandle::Get(),
-        base::ThreadTaskRunnerHandle::Get(), media_thread_.task_runner(),
+        media_thread_.task_runner(), media_thread_.task_runner(),
+        media_thread_.task_runner(), media_thread_.task_runner(),
         base::BindRepeating(&WebMediaPlayerImplTest::OnAdjustAllocatedMemory,
                             base::Unretained(this)),
         nullptr, RequestRoutingTokenCallback(), nullptr, false, false,