Remove calls to deprecated MessageLoop methods in media.

media/cast/test/cast_benchmarks.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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
@@ skipping 19 matching lines @@
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/profiler.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.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/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
@@ skipping 598 matching lines @@
                       double accuracy,
                       std::vector<linked_ptr<base::Thread> >* threads) {
     static int thread_num = 0;
     if (x > max) return;
     if (skip > max) {
       if (y > x) return;
       SearchVector ab = a.blend(b, static_cast<double>(x) / max);
       SearchVector ac = a.blend(c, static_cast<double>(x) / max);
       SearchVector v = ab.blend(ac, x == y ? 1.0 : static_cast<double>(y) / x);
       thread_num++;
-      (*threads)[thread_num % threads->size()]->message_loop()->PostTask(
-          FROM_HERE,
-          base::Bind(&CastBenchmark::BinarySearch,
-                     base::Unretained(this),
-                     v,
-                     accuracy));
+      (*threads)[thread_num % threads->size()]
+          ->message_loop()
+          ->task_runner()
+          ->PostTask(FROM_HERE,
+                     base::Bind(&CastBenchmark::BinarySearch,
+                                base::Unretained(this), v, accuracy));
     } else {
       skip *= 2;
       SpanningSearch(max, x, y, skip, a, b, c, accuracy, threads);
       SpanningSearch(max, x + skip, y + skip, skip, a, b, c, accuracy, threads);
       SpanningSearch(max, x + skip, y, skip, a, b, c, accuracy, threads);
       SpanningSearch(max, x, y + skip, skip, a, b, c, accuracy, threads);
     }
   }
 
   void Run() {
     // Spanning search.
 
     std::vector<linked_ptr<base::Thread> > threads;
     for (int i = 0; i < 16; i++) {
       threads.push_back(make_linked_ptr(new base::Thread(
           base::StringPrintf("cast_bench_thread_%d", i))));
       threads[i]->Start();
     }
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch("single-run")) {
       SearchVector a;
       a.bitrate.base = 100.0;
       a.bitrate.grade = 1.0;
       a.latency.grade = 1.0;
       a.packet_drop.grade = 1.0;
-      threads[0]->message_loop()->PostTask(
-          FROM_HERE,
-          base::Bind(base::IgnoreResult(&CastBenchmark::RunOnePoint),
-                     base::Unretained(this),
-                     a,
-                     1.0));
+      threads[0]->message_loop()->task_runner()->PostTask(
+          FROM_HERE, base::Bind(base::IgnoreResult(&CastBenchmark::RunOnePoint),
+                                base::Unretained(this), a, 1.0));
     } else {
       SearchVector a, b, c;
       a.bitrate.base = b.bitrate.base = c.bitrate.base = 100.0;
       a.bitrate.grade = 1.0;
       b.latency.grade = 1.0;
       c.packet_drop.grade = 1.0;
 
       SpanningSearch(512,
                      0,
                      0,
@@ skipping 24 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }