Update MockWebUserMediaClient for requestSources.

content/shell/renderer/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 "content/shell/renderer/test_runner/mock_web_user_media_client.h"
 
 #include "base/logging.h"
+#include "base/macros.h"
 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
 #include "content/shell/renderer/test_runner/mock_constraints.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;
 using blink::WebString;
 using blink::WebUserMediaRequest;
 using blink::WebVector;
 
 namespace content {
 
 class UserMediaRequestTask : public WebMethodTask<MockWebUserMediaClient> {
  public:
   UserMediaRequestTask(MockWebUserMediaClient* object,
                        const WebUserMediaRequest& request,
                        const WebMediaStream result)
       : WebMethodTask<MockWebUserMediaClient>(object),
         request_(request),
         result_(result) {
     DCHECK(!result_.isNull());
   }
 
   virtual void RunIfValid() OVERRIDE { request_.requestSucceeded(result_); }
 
  private:
   WebUserMediaRequest request_;
   WebMediaStream result_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserMediaRequestTask);
 };
 
 class UserMediaRequestConstraintFailedTask
     : public WebMethodTask<MockWebUserMediaClient> {
  public:
   UserMediaRequestConstraintFailedTask(MockWebUserMediaClient* object,
                                        const WebUserMediaRequest& request,
                                        const WebString& constraint)
       : WebMethodTask<MockWebUserMediaClient>(object),
         request_(request),
         constraint_(constraint) {}
 
   virtual void RunIfValid() OVERRIDE {
     request_.requestFailedConstraint(constraint_);
   }
 
  private:
   WebUserMediaRequest request_;
   WebString constraint_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserMediaRequestConstraintFailedTask);
 };
 
 class UserMediaRequestPermissionDeniedTask
     : public WebMethodTask<MockWebUserMediaClient> {
  public:
   UserMediaRequestPermissionDeniedTask(MockWebUserMediaClient* object,
                                        const WebUserMediaRequest& request)
       : WebMethodTask<MockWebUserMediaClient>(object),
         request_(request) {}
 
   virtual void RunIfValid() OVERRIDE { request_.requestFailed(); }
 
  private:
   WebUserMediaRequest request_;
+
+  DISALLOW_COPY_AND_ASSIGN(UserMediaRequestPermissionDeniedTask);
 };
 
 class MediaDevicesRequestTask : public WebMethodTask<MockWebUserMediaClient> {
  public:
   MediaDevicesRequestTask(MockWebUserMediaClient* object,
                           const WebMediaDevicesRequest& request,
                           const WebVector<WebMediaDeviceInfo>& result)
       : WebMethodTask<MockWebUserMediaClient>(object),
         request_(request),
         result_(result) {}
 
   virtual void RunIfValid() OVERRIDE { request_.requestSucceeded(result_); }
 
  private:
   WebMediaDevicesRequest request_;
   WebVector<WebMediaDeviceInfo> result_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaDevicesRequestTask);
+};
+
+class SourcesRequestTask : public WebMethodTask<MockWebUserMediaClient> {
+ public:
+  SourcesRequestTask(MockWebUserMediaClient* object,
+                     const WebMediaStreamTrackSourcesRequest& request,
+                     const WebVector<WebSourceInfo>& result)
+      : WebMethodTask<MockWebUserMediaClient>(object),
+        request_(request),
+        result_(result) {}
+
+  virtual void RunIfValid() OVERRIDE { request_.requestSucceeded(result_); }
+
+ private:
+  WebMediaStreamTrackSourcesRequest request_;
+  WebVector<WebSourceInfo> result_;
+
+  DISALLOW_COPY_AND_ASSIGN(SourcesRequestTask);
 };
 
 class MockExtraData : public WebMediaStream::ExtraData {
  public:
   int foo;
 };
 
 MockWebUserMediaClient::MockWebUserMediaClient(WebTestDelegate* delegate)
     : delegate_(delegate) {}
 
@@ skipping 52 matching lines @@
 
     delegate_->postTask(new UserMediaRequestTask(this, request, stream));
 }
 
 void MockWebUserMediaClient::cancelUserMediaRequest(
     const WebUserMediaRequest&) {
 }
 
 void MockWebUserMediaClient::requestMediaDevices(
     const WebMediaDevicesRequest& request) {
-  const size_t three = 3;
-  WebVector<WebMediaDeviceInfo> devices(three);
+  struct {
+    const char* device_id;
+    WebMediaDeviceInfo::MediaDeviceKind kind;
+    const char* label;
+    const char* group_id;
+  } test_devices[] = {
+    {
+      "device1",
+      WebMediaDeviceInfo::MediaDeviceKindAudioInput,
+      "Built-in microphone",
+      "group1",
+    },
+    {
+      "device2",
+      WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
+      "Built-in speakers",
+      "group1",
+    },
+    {
+      "device3",
+      WebMediaDeviceInfo::MediaDeviceKindVideoInput,
+      "Build-in webcam",
+      "group2",
+    },
+  };
 
-  devices[0].initialize("device1",
-                        WebMediaDeviceInfo::MediaDeviceKindAudioInput,
-                        "Built-in microphone",
-                        "group1");
-  devices[1].initialize("device2",
-                        WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
-                        "Built-in speakers",
-                        "group1");
-  devices[2].initialize("device3",
-                        WebMediaDeviceInfo::MediaDeviceKindVideoInput,
-                        "Build-in webcam",
-                        "group2");
+  WebVector<WebMediaDeviceInfo> devices(ARRAYSIZE_UNSAFE(test_devices));
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(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 {
+    const char* id;
+    WebSourceInfo::SourceKind kind;
+    const char* label;
+    WebSourceInfo::VideoFacingMode facing;
+  } test_sources[] = {
+    {
+      "device1",
+      WebSourceInfo::SourceKindAudio,
+      "Built-in microphone",
+      WebSourceInfo::VideoFacingModeNone,
+    },
+    {
+      "device2",
+      WebSourceInfo::SourceKindVideo,
+      "Build-in webcam",
+      WebSourceInfo::VideoFacingModeEnvironment,
+    },
+  };
+
+  WebVector<WebSourceInfo> sources(ARRAYSIZE_UNSAFE(test_sources));
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_sources); ++i) {
+  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 content