src/content/shell/renderer/test_runner/mock_web_user_media_client.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/shell/renderer/test_runner/mock_web_user_media_client.h"
   6
   7 #include "base/logging.h"
   8 #include "base/macros.h"
   9 #include "content/shell/renderer/test_runner/mock_constraints.h"
  10 #include "content/shell/renderer/test_runner/web_test_delegate.h"
  11 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
  12 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
  13 #include "third_party/WebKit/public/platform/WebMediaStream.h"
  14 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  15 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  16 #include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h"
  17 #include "third_party/WebKit/public/platform/WebSourceInfo.h"
  18 #include "third_party/WebKit/public/platform/WebVector.h"
  19 #include "third_party/WebKit/public/web/WebDocument.h"
  20 #include "third_party/WebKit/public/web/WebMediaDevicesRequest.h"
  21 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
  22 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
  23
  24 using blink::WebMediaConstraints;
  25 using blink::WebMediaDeviceInfo;
  26 using blink::WebMediaDevicesRequest;
  27 using blink::WebMediaStream;
  28 using blink::WebMediaStreamSource;
  29 using blink::WebMediaStreamTrack;
  30 using blink::WebMediaStreamTrackSourcesRequest;
  31 using blink::WebSourceInfo;
  32 using blink::WebString;
  33 using blink::WebUserMediaRequest;
  34 using blink::WebVector;
  35
  36 namespace content {
  37
  38 class UserMediaRequestTask : public WebMethodTask<MockWebUserMediaClient> {
  39  public:
  40   UserMediaRequestTask(MockWebUserMediaClient* object,
  41                        const WebUserMediaRequest& request,
  42                        const WebMediaStream result)
  43       : WebMethodTask<MockWebUserMediaClient>(object),
  44         request_(request),
  45         result_(result) {
  46     DCHECK(!result_.isNull());
  47   }
  48
  49   void RunIfValid() override { request_.requestSucceeded(result_); }
  50
  51  private:
  52   WebUserMediaRequest request_;
  53   WebMediaStream result_;
  54
  55   DISALLOW_COPY_AND_ASSIGN(UserMediaRequestTask);
  56 };
  57
  58 class UserMediaRequestConstraintFailedTask
  59     : public WebMethodTask<MockWebUserMediaClient> {
  60  public:
  61   UserMediaRequestConstraintFailedTask(MockWebUserMediaClient* object,
  62                                        const WebUserMediaRequest& request,
  63                                        const WebString& constraint)
  64       : WebMethodTask<MockWebUserMediaClient>(object),
  65         request_(request),
  66         constraint_(constraint) {}
  67
  68   void RunIfValid() override { request_.requestFailedConstraint(constraint_); }
  69
  70  private:
  71   WebUserMediaRequest request_;
  72   WebString constraint_;
  73
  74   DISALLOW_COPY_AND_ASSIGN(UserMediaRequestConstraintFailedTask);
  75 };
  76
  77 class UserMediaRequestPermissionDeniedTask
  78     : public WebMethodTask<MockWebUserMediaClient> {
  79  public:
  80   UserMediaRequestPermissionDeniedTask(MockWebUserMediaClient* object,
  81                                        const WebUserMediaRequest& request)
  82       : WebMethodTask<MockWebUserMediaClient>(object),
  83         request_(request) {}
  84
  85   void RunIfValid() override { request_.requestFailed(); }
  86
  87  private:
  88   WebUserMediaRequest request_;
  89
  90   DISALLOW_COPY_AND_ASSIGN(UserMediaRequestPermissionDeniedTask);
  91 };
  92
  93 class MediaDevicesRequestTask : public WebMethodTask<MockWebUserMediaClient> {
  94  public:
  95   MediaDevicesRequestTask(MockWebUserMediaClient* object,
  96                           const WebMediaDevicesRequest& request,
  97                           const WebVector<WebMediaDeviceInfo>& result)
  98       : WebMethodTask<MockWebUserMediaClient>(object),
  99         request_(request),
 100         result_(result) {}
 101
 102   void RunIfValid() override { request_.requestSucceeded(result_); }
 103
 104  private:
 105   WebMediaDevicesRequest request_;
 106   WebVector<WebMediaDeviceInfo> result_;
 107
 108   DISALLOW_COPY_AND_ASSIGN(MediaDevicesRequestTask);
 109 };
 110
 111 class SourcesRequestTask : public WebMethodTask<MockWebUserMediaClient> {
 112  public:
 113   SourcesRequestTask(MockWebUserMediaClient* object,
 114                      const WebMediaStreamTrackSourcesRequest& request,
 115                      const WebVector<WebSourceInfo>& result)
 116       : WebMethodTask<MockWebUserMediaClient>(object),
 117         request_(request),
 118         result_(result) {}
 119
 120   void RunIfValid() override { request_.requestSucceeded(result_); }
 121
 122  private:
 123   WebMediaStreamTrackSourcesRequest request_;
 124   WebVector<WebSourceInfo> result_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(SourcesRequestTask);
 127 };
 128
 129 class MockExtraData : public WebMediaStream::ExtraData {
 130  public:
 131   int foo;
 132 };
 133
 134 MockWebUserMediaClient::MockWebUserMediaClient(WebTestDelegate* delegate)
 135     : delegate_(delegate) {}
 136
 137 void MockWebUserMediaClient::requestUserMedia(
 138     const WebUserMediaRequest& stream_request) {
 139     DCHECK(!stream_request.isNull());
 140     WebUserMediaRequest request = stream_request;
 141
 142     if (request.ownerDocument().isNull() || !request.ownerDocument().frame()) {
 143       delegate_->PostTask(
 144           new UserMediaRequestPermissionDeniedTask(this, request));
 145         return;
 146     }
 147
 148     WebMediaConstraints constraints = request.audioConstraints();
 149     WebString failed_constraint;
 150     if (!constraints.isNull() &&
 151         !MockConstraints::VerifyConstraints(constraints, &failed_constraint)) {
 152       delegate_->PostTask(new UserMediaRequestConstraintFailedTask(
 153           this, request, failed_constraint));
 154       return;
 155     }
 156     constraints = request.videoConstraints();
 157     if (!constraints.isNull() &&
 158         !MockConstraints::VerifyConstraints(constraints, &failed_constraint)) {
 159       delegate_->PostTask(new UserMediaRequestConstraintFailedTask(
 160           this, request, failed_constraint));
 161       return;
 162     }
 163
 164     const size_t zero = 0;
 165     const size_t one = 1;
 166     WebVector<WebMediaStreamTrack> audio_tracks(request.audio() ? one : zero);
 167     WebVector<WebMediaStreamTrack> video_tracks(request.video() ? one : zero);
 168
 169     if (request.audio()) {
 170       WebMediaStreamSource source;
 171       source.initialize("MockAudioDevice#1",
 172                         WebMediaStreamSource::TypeAudio,
 173                         "Mock audio device");
 174       audio_tracks[0].initialize(source);
 175     }
 176
 177     if (request.video()) {
 178       WebMediaStreamSource source;
 179       source.initialize("MockVideoDevice#1",
 180                         WebMediaStreamSource::TypeVideo,
 181                         "Mock video device");
 182       video_tracks[0].initialize(source);
 183     }
 184
 185     WebMediaStream stream;
 186     stream.initialize(audio_tracks, video_tracks);
 187
 188     stream.setExtraData(new MockExtraData());
 189
 190     delegate_->PostTask(new UserMediaRequestTask(this, request, stream));
 191 }
 192
 193 void MockWebUserMediaClient::cancelUserMediaRequest(
 194     const WebUserMediaRequest&) {
 195 }
 196
 197 void MockWebUserMediaClient::requestMediaDevices(
 198     const WebMediaDevicesRequest& request) {
 199   struct {
 200     const char* device_id;
 201     WebMediaDeviceInfo::MediaDeviceKind kind;
 202     const char* label;
 203     const char* group_id;
 204   } test_devices[] = {
 205     {
 206       "device1",
 207       WebMediaDeviceInfo::MediaDeviceKindAudioInput,
 208       "Built-in microphone",
 209       "group1",
 210     },
 211     {
 212       "device2",
 213       WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
 214       "Built-in speakers",
 215       "group1",
 216     },
 217     {
 218       "device3",
 219       WebMediaDeviceInfo::MediaDeviceKindVideoInput,
 220       "Build-in webcam",
 221       "group2",
 222     },
 223   };
 224
 225   WebVector<WebMediaDeviceInfo> devices(arraysize(test_devices));
 226   for (size_t i = 0; i < arraysize(test_devices); ++i) {
 227     devices[i].initialize(WebString::fromUTF8(test_devices[i].device_id),
 228                           test_devices[i].kind,
 229                           WebString::fromUTF8(test_devices[i].label),
 230                           WebString::fromUTF8(test_devices[i].group_id));
 231   }
 232
 233   delegate_->PostTask(new MediaDevicesRequestTask(this, request, devices));
 234 }
 235
 236 void MockWebUserMediaClient::cancelMediaDevicesRequest(
 237     const WebMediaDevicesRequest&) {
 238 }
 239
 240 void MockWebUserMediaClient::requestSources(
 241     const blink::WebMediaStreamTrackSourcesRequest& request) {
 242   struct {
 243     const char* id;
 244     WebSourceInfo::SourceKind kind;
 245     const char* label;
 246     WebSourceInfo::VideoFacingMode facing;
 247   } test_sources[] = {
 248     {
 249       "device1",
 250       WebSourceInfo::SourceKindAudio,
 251       "Built-in microphone",
 252       WebSourceInfo::VideoFacingModeNone,
 253     },
 254     {
 255       "device2",
 256       WebSourceInfo::SourceKindVideo,
 257       "Build-in webcam",
 258       WebSourceInfo::VideoFacingModeEnvironment,
 259     },
 260   };
 261
 262   WebVector<WebSourceInfo> sources(arraysize(test_sources));
 263   for (size_t i = 0; i < arraysize(test_sources); ++i) {
 264   sources[i].initialize(WebString::fromUTF8(test_sources[i].id),
 265                         test_sources[i].kind,
 266                         WebString::fromUTF8(test_sources[i].label),
 267                         test_sources[i].facing);
 268   }
 269
 270   delegate_->PostTask(new SourcesRequestTask(this, request, sources));
 271 }
 272
 273 }  // namespace content