Extend components/test_runner's generated WebMediaStream to have a ChromeMock VideoTrack and Source

components/test_runner/mock_web_user_media_client.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 "components/test_runner/mock_web_user_media_client.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "components/test_runner/mock_constraints.h"
+#include "components/test_runner/renderer/mock_video_capturer_source.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h"
 #include "third_party/WebKit/public/platform/WebSourceInfo.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h"
-#include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 
 using blink::WebMediaConstraints;
 using blink::WebMediaDeviceInfo;
 using blink::WebMediaDevicesRequest;
 using blink::WebMediaStream;
 using blink::WebMediaStreamSource;
 using blink::WebMediaStreamTrack;
 using blink::WebMediaStreamTrackSourcesRequest;
 using blink::WebSourceInfo;
@@ skipping 87 matching lines @@
 
   void RunIfValid() override { request_.requestSucceeded(result_); }
 
  private:
   WebMediaStreamTrackSourcesRequest request_;
   WebVector<WebSourceInfo> result_;
 
   DISALLOW_COPY_AND_ASSIGN(SourcesRequestTask);
 };
 
-class MockExtraData : public WebMediaStream::ExtraData {
+class MockStreamExtraData : public WebMediaStream::ExtraData {
  public:
   int foo;
 };
 
 MockWebUserMediaClient::MockWebUserMediaClient(WebTestDelegate* delegate)
     : delegate_(delegate) {}
 
 void MockWebUserMediaClient::requestUserMedia(
     const WebUserMediaRequest& stream_request) {
     DCHECK(!stream_request.isNull());
@@ skipping 17 matching lines @@
     if (!constraints.isNull() &&
         !MockConstraints::VerifyConstraints(constraints, &failed_constraint)) {
       delegate_->PostTask(new UserMediaRequestConstraintFailedTask(
           this, request, failed_constraint));
       return;
     }
 
     const size_t zero = 0;
     const size_t one = 1;
     WebVector<WebMediaStreamTrack> audio_tracks(request.audio() ? one : zero);
-    WebVector<WebMediaStreamTrack> video_tracks(request.video() ? one : zero);
-
     if (request.audio()) {
       WebMediaStreamSource source;
       source.initialize("MockAudioDevice#1",
                         WebMediaStreamSource::TypeAudio,
                         "Mock audio device",
                         false /* remote */, true /* readonly */);
       audio_tracks[0].initialize(source);
     }
 
+    WebMediaStream stream;
+    const WebVector<WebMediaStreamTrack> empty_track_vector;
+    stream.initialize(audio_tracks, empty_track_vector);
+    stream.setExtraData(new MockStreamExtraData());
+
     if (request.video()) {
-      WebMediaStreamSource source;
-      source.initialize("MockVideoDevice#1",
-                        WebMediaStreamSource::TypeVideo,
-                        "Mock video device",
-                        false /* remote */, true /* readonly */);
-      video_tracks[0].initialize(source);
+      content::AddVideoTrackToMediaStream(
+          make_scoped_ptr(new MockVideoCapturerSource()),
+          false /*is _remote */,
+          true /* is_readonly */,
+          &stream);
     }
 
-    WebMediaStream stream;
-    stream.initialize(audio_tracks, video_tracks);
-
-    stream.setExtraData(new MockExtraData());
-
     delegate_->PostTask(new UserMediaRequestTask(this, request, stream));
 }
 
 void MockWebUserMediaClient::cancelUserMediaRequest(
     const WebUserMediaRequest&) {
 }
 
 void MockWebUserMediaClient::requestMediaDevices(
     const WebMediaDevicesRequest& request) {
   struct {
@@ skipping 22 matching lines @@
     },
   };
 
   WebVector<WebMediaDeviceInfo> devices(arraysize(test_devices));
   for (size_t i = 0; i < arraysize(test_devices); ++i) {
     devices[i].initialize(WebString::fromUTF8(test_devices[i].device_id),
                           test_devices[i].kind,
                           WebString::fromUTF8(test_devices[i].label),
                           WebString::fromUTF8(test_devices[i].group_id));
   }
-
   delegate_->PostTask(new MediaDevicesRequestTask(this, request, devices));
 }
 
 void MockWebUserMediaClient::cancelMediaDevicesRequest(
     const WebMediaDevicesRequest&) {
 }
 
 void MockWebUserMediaClient::requestSources(
     const blink::WebMediaStreamTrackSourcesRequest& request) {
   struct {
@@ skipping 21 matching lines @@
   sources[i].initialize(WebString::fromUTF8(test_sources[i].id),
                         test_sources[i].kind,
                         WebString::fromUTF8(test_sources[i].label),
                         test_sources[i].facing);
   }
 
   delegate_->PostTask(new SourcesRequestTask(this, request, sources));
 }
 
 }  // namespace test_runner