Move passing of WebRTC rendering frames to IO thread

content/renderer/media/webmediaplayer_ms_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
@@ skipping 290 matching lines @@
   MockRenderFactory(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       ReusableMessageLoopEvent* message_loop_controller)
       : task_runner_(task_runner),
         message_loop_controller_(message_loop_controller) {}
 
   scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
       const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
-      const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories) override;
 
   MockMediaStreamVideoRenderer* provider() {
     return static_cast<MockMediaStreamVideoRenderer*>(provider_.get());
   }
 
   scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
       const std::string& device_id,
       const url::Origin& security_origin) override {
     return nullptr;
   }
 
  private:
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<MediaStreamVideoRenderer> provider_;
   ReusableMessageLoopEvent* const message_loop_controller_;
 };
 
 scoped_refptr<MediaStreamVideoRenderer> MockRenderFactory::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
     const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
-    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories) {
   provider_ = new MockMediaStreamVideoRenderer(task_runner_,
       message_loop_controller_, error_cb, repaint_cb);
 
   return provider_;
 }
 
 // This is the main class coordinating the tests.
@@ skipping 27 matching lines @@
                                               &message_loop_controller_)),
         player_(new WebMediaPlayerMS(
             nullptr,
             this,
             delegate_.AsWeakPtr(),
             new media::MediaLog(),
             std::unique_ptr<MediaStreamRendererFactory>(render_factory_),
             message_loop_.task_runner(),
             message_loop_.task_runner(),
             message_loop_.task_runner(),
+            message_loop_.task_runner(),
             nullptr,
             blink::WebString(),
             blink::WebSecurityOrigin())),
         rendering_(false),
         background_rendering_(false) {}
   ~WebMediaPlayerMSTest() override {
     player_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 539 matching lines @@
   // OnShown() should restart after a forced suspension.
   player_->OnShown();
   EXPECT_FALSE(player_->paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 
   base::RunLoop().RunUntilIdle();
 }
 #endif
 
 }  // namespace content