Change media MessageLoopProxy usage to SingleThreadTaskRunners.

content/renderer/media/buffered_data_source.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
 #define CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/buffered_resource_loader.h"
 #include "content/renderer/media/preload.h"
 #include "media/base/data_source.h"
 #include "media/base/ranges.h"
 #include "url/gurl.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;
 }
 
 namespace media {
 class MediaLog;
 }
 
 namespace content {
 
 class CONTENT_EXPORT BufferedDataSourceHost {
  public:
@@ skipping 14 matching lines @@
 //
 // BufferedDataSource must be created and initialized on the render thread
 // before being passed to other threads. It may be deleted on any thread.
 class CONTENT_EXPORT BufferedDataSource : public media::DataSource {
  public:
   typedef base::Callback<void(bool)> DownloadingCB;
 
   // |url| and |cors_mode| are passed to the object. Buffered byte range changes
   // will be reported to |host|. |downloading_cb| will be called whenever the
   // downloading/paused state of the source changes.
-  BufferedDataSource(const GURL& url,
-                     BufferedResourceLoader::CORSMode cors_mode,
-                     const scoped_refptr<base::MessageLoopProxy>& render_loop,
-                     blink::WebFrame* frame,
-                     media::MediaLog* media_log,
-                     BufferedDataSourceHost* host,
-                     const DownloadingCB& downloading_cb);
+  BufferedDataSource(
+      const GURL& url,
+      BufferedResourceLoader::CORSMode cors_mode,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      blink::WebFrame* frame,
+      media::MediaLog* media_log,
+      BufferedDataSourceHost* host,
+      const DownloadingCB& downloading_cb);
   virtual ~BufferedDataSource();
 
   // Executes |init_cb| with the result of initialization when it has completed.
   //
   // Method called on the render thread.
   typedef base::Callback<void(bool)> InitializeCB;
   void Initialize(const InitializeCB& init_cb);
 
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload);
@@ skipping 110 matching lines @@
   // we don't own |read_buffer_|. But since the read operation is asynchronous,
   // |read_buffer| can be destroyed at any time, so we only copy into
   // |read_buffer| in the final step when it is safe.
   // Memory is allocated for this member during initialization of this object
   // because we want buffer to be passed into BufferedResourceLoader to be
   // always non-null. And by initializing this member with a default size we can
   // avoid creating zero-sized buffered if the first read has zero size.
   scoped_ptr<uint8[]> intermediate_read_buffer_;
   int intermediate_read_buffer_size_;
 
-  // The message loop of the render thread.
-  const scoped_refptr<base::MessageLoopProxy> render_loop_;
+  // The task runner of the render thread.
+  const scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_;
 
   // Protects |stop_signal_received_| and |read_op_|.
   base::Lock lock_;
 
   // Whether we've been told to stop via Abort() or Stop().
   bool stop_signal_received_;
 
   // This variable is true when the user has requested the video to play at
   // least once.
   bool media_has_played_;
@@ skipping 17 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<BufferedDataSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_