Add srcObject attribute of type MediaStream to HTMLMediaElement.

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 "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/webmediaplayer_ms.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
+#include "third_party/WebKit/public/platform/WebMediaElementSource.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 
 namespace content {
 
 enum class FrameType {
   NORMAL_FRAME = 0,
   BROKEN_FRAME = -1,
   TEST_BRAKE = -2,  // Signal to pause message loop.
   MIN_TYPE = TEST_BRAKE
@@ skipping 243 matching lines @@
 // WebMediaPlayerMS::load().
 class MockRenderFactory : public MediaStreamRendererFactory {
  public:
   MockRenderFactory(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       ReusableMessageLoopEvent* message_loop_controller)
       : task_runner_(task_runner),
         message_loop_controller_(message_loop_controller) {}
 
   scoped_refptr<VideoFrameProvider> GetVideoFrameProvider(
-      const GURL& url,
+      const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
       const VideoFrameProvider::RepaintCB& repaint_cb,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories) override;
 
   MockVideoFrameProvider* provider() {
     return static_cast<MockVideoFrameProvider*>(provider_.get());
   }
 
   scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
-      const GURL& url,
+      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<VideoFrameProvider> provider_;
   ReusableMessageLoopEvent* const message_loop_controller_;
 };
 
 scoped_refptr<VideoFrameProvider> MockRenderFactory::GetVideoFrameProvider(
-    const GURL& url,
+    const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
     const VideoFrameProvider::RepaintCB& repaint_cb,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories) {
   provider_ = new MockVideoFrameProvider(task_runner_, message_loop_controller_,
                                          error_cb, repaint_cb);
 
   return provider_;
 }
@@ skipping 115 matching lines @@
 
 MockVideoFrameProvider* WebMediaPlayerMSTest::LoadAndGetFrameProvider(
     bool algorithm_enabled) {
   EXPECT_FALSE(!!render_factory_->provider()) << "There should not be a "
                                                  "FrameProvider yet.";
 
   EXPECT_CALL(
       *this, DoNetworkStateChanged(blink::WebMediaPlayer::NetworkStateLoading));
   EXPECT_CALL(
       *this, DoReadyStateChanged(blink::WebMediaPlayer::ReadyStateHaveNothing));
-  player_.load(blink::WebMediaPlayer::LoadTypeURL, blink::WebURL(),
+  player_.load(blink::WebMediaPlayer::LoadTypeURL,
+               blink::WebMediaElementSource(),
                blink::WebMediaPlayer::CORSModeUnspecified);
   compositor_ = player_.compositor_.get();
   EXPECT_TRUE(!!compositor_);
   compositor_->SetAlgorithmEnabledForTesting(algorithm_enabled);
 
   MockVideoFrameProvider* const provider = render_factory_->provider();
   EXPECT_TRUE(!!provider);
   EXPECT_TRUE(provider->Started());
 
   testing::Mock::VerifyAndClearExpectations(this);
@@ skipping 298 matching lines @@
   EXPECT_TRUE(player_.paused());
 
   // OnShown() should restart after a forced suspension.
   player_.OnShown();
   EXPECT_FALSE(player_.paused());
   EXPECT_CALL(*this, DoSetWebLayer(false));
 }
 #endif
 
 }  // namespace content