Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/media/cma/ipc/media_message_fifo_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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "chromecast/media/cma/ipc/media_memory_chunk.h"
@@ skipping 117 matching lines @@
   scoped_ptr<MediaMessageFifo> producer_fifo(new MediaMessageFifo(
       scoped_ptr<MediaMemoryChunk>(
           new FifoMemoryChunk(&buffer[0], buffer_size)),
       true));
   scoped_ptr<MediaMessageFifo> consumer_fifo(new MediaMessageFifo(
       scoped_ptr<MediaMemoryChunk>(
           new FifoMemoryChunk(&buffer[0], buffer_size)),
       false));
 
   base::WaitableEvent event(false, false);
-  thread->message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&MsgProducerConsumer,
-                 base::Passed(&producer_fifo),
-                 base::Passed(&consumer_fifo),
-                 &event));
+  thread->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MsgProducerConsumer, base::Passed(&producer_fifo),
+                            base::Passed(&consumer_fifo), &event));
   event.Wait();
 
   thread.reset();
 }
 
 TEST(MediaMessageFifoTest, MultiThreaded) {
   size_t buffer_size = 64 * 1024;
   scoped_ptr<uint64[]> buffer(new uint64[buffer_size / sizeof(uint64)]);
 
   scoped_ptr<base::Thread> producer_thread(
       new base::Thread("FeederThread"));
   scoped_ptr<base::Thread> consumer_thread(
       new base::Thread("ConsumerThread"));
   producer_thread->Start();
   consumer_thread->Start();
 
   scoped_ptr<MediaMessageFifo> producer_fifo(new MediaMessageFifo(
       scoped_ptr<MediaMemoryChunk>(
           new FifoMemoryChunk(&buffer[0], buffer_size)),
       true));
   scoped_ptr<MediaMessageFifo> consumer_fifo(new MediaMessageFifo(
       scoped_ptr<MediaMemoryChunk>(
           new FifoMemoryChunk(&buffer[0], buffer_size)),
       false));
 
   base::WaitableEvent producer_event_done(false, false);
   base::WaitableEvent consumer_event_done(false, false);
 
   const int msg_count = 2048;
-  producer_thread->message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&MsgProducer,
-                 base::Passed(&producer_fifo),
-                 msg_count,
-                 &producer_event_done));
-  consumer_thread->message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&MsgConsumer,
-                 base::Passed(&consumer_fifo),
-                 msg_count,
-                 &consumer_event_done));
+  producer_thread->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MsgProducer, base::Passed(&producer_fifo),
+                            msg_count, &producer_event_done));
+  consumer_thread->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&MsgConsumer, base::Passed(&consumer_fifo),
+                            msg_count, &consumer_event_done));
 
   producer_event_done.Wait();
   consumer_event_done.Wait();
 
   producer_thread.reset();
   consumer_thread.reset();
 }
 
 }  // namespace media
 }  // namespace chromecast