Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/media/cma/base/balanced_media_task_runner_unittest.cc

 // Copyright 2014 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 <list>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chromecast/media/cma/base/balanced_media_task_runner_factory.h"
 #include "chromecast/media/cma/base/media_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
@@ skipping 71 matching lines @@
 
   scheduling_pattern_ = pattern;
   pattern_index_ = 0;
 
   // Setup each task runner.
   size_t n = timestamps_in_ms.size();
   contexts_.resize(n);
   for (size_t k = 0; k < n; k++) {
     contexts_[k].media_task_runner =
         media_task_runner_factory_->CreateMediaTaskRunner(
-            base::MessageLoopProxy::current());
+            base::ThreadTaskRunnerHandle::Get());
     contexts_[k].is_pending_task = false;
     contexts_[k].task_index = 0;
     contexts_[k].task_timestamp_list.resize(
         timestamps_in_ms[k].size());
     for (size_t i = 0; i < timestamps_in_ms[k].size(); i++) {
       contexts_[k].task_timestamp_list[i] =
           base::TimeDelta::FromMilliseconds(timestamps_in_ms[k][i]);
     }
   }
 
@@ skipping 28 matching lines @@
       (pattern_index_ + 1) % scheduling_pattern_.size();
 
   size_t task_runner_id = scheduling_pattern_[pattern_index_];
   MediaTaskRunnerTestContext& context = contexts_[task_runner_id];
 
   // Check whether all tasks have been scheduled for that task runner
   // or if there is already one pending task.
   if (context.task_index >= context.task_timestamp_list.size() ||
       context.is_pending_task) {
     pattern_index_ = next_pattern_index;
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&BalancedMediaTaskRunnerTest::ScheduleTask,
-                   base::Unretained(this)));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&BalancedMediaTaskRunnerTest::ScheduleTask,
+                              base::Unretained(this)));
     return;
   }
 
   bool expected_may_run = false;
   if (context.task_timestamp_list[context.task_index] >=
       context.max_timestamp) {
     expected_may_run = true;
     context.max_timestamp = context.task_timestamp_list[context.task_index];
   }
 
   bool may_run = context.media_task_runner->PostMediaTask(
       FROM_HERE,
       base::Bind(&BalancedMediaTaskRunnerTest::Task,
                  base::Unretained(this),
                  task_runner_id,
                  context.task_timestamp_list[context.task_index]),
       context.task_timestamp_list[context.task_index]);
   EXPECT_EQ(may_run, expected_may_run);
 
   if (may_run)
     context.is_pending_task = true;
 
   context.task_index++;
   pattern_index_ = next_pattern_index;
-  base::MessageLoopProxy::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&BalancedMediaTaskRunnerTest::ScheduleTask,
-                 base::Unretained(this)));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&BalancedMediaTaskRunnerTest::ScheduleTask,
+                            base::Unretained(this)));
 }
 
 void BalancedMediaTaskRunnerTest::Task(
     size_t task_runner_id, base::TimeDelta timestamp) {
   ASSERT_FALSE(expected_task_timestamps_.empty());
   EXPECT_EQ(timestamp, expected_task_timestamps_.front());
   expected_task_timestamps_.pop_front();
 
   contexts_[task_runner_id].is_pending_task = false;
 }
@@ skipping 60 matching lines @@
             timestamps_ms,
             scheduling_pattern,
             expected_timestamps_ms);
   ProcessAllTasks();
   message_loop->Run();
   EXPECT_TRUE(expected_task_timestamps_.empty());
 }
 
 }  // namespace media
 }  // namespace chromecast