src/content/public/common/media_stream_request.h

   1 // Copyright (c) 2012 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 #ifndef CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
   6 #define CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/callback_forward.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "content/common/content_export.h"
  16 #include "ui/gfx/native_widget_types.h"
  17 #include "url/gurl.h"
  18
  19 namespace content {
  20
  21 // Types of media streams.
  22 enum MediaStreamType {
  23   MEDIA_NO_SERVICE = 0,
  24
  25   // A device provided by the operating system (e.g., webcam input).
  26   MEDIA_DEVICE_AUDIO_CAPTURE,
  27   MEDIA_DEVICE_VIDEO_CAPTURE,
  28
  29   // Mirroring of a browser tab.
  30   MEDIA_TAB_AUDIO_CAPTURE,
  31   MEDIA_TAB_VIDEO_CAPTURE,
  32
  33   // Desktop media sources.
  34   MEDIA_DESKTOP_VIDEO_CAPTURE,
  35
  36   // Capture system audio (post-mix loopback stream).
  37   //
  38   // TODO(sergeyu): Replace with MEDIA_DESKTOP_AUDIO_CAPTURE.
  39   MEDIA_LOOPBACK_AUDIO_CAPTURE,
  40
  41   // This is used for enumerating audio output devices.
  42   // TODO(grunell): Output isn't really a part of media streams. Device
  43   // enumeration should be decoupled from media streams and related code.
  44   MEDIA_DEVICE_AUDIO_OUTPUT,
  45
  46   NUM_MEDIA_TYPES
  47 };
  48
  49 // Types of media stream requests that can be made to the media controller.
  50 enum MediaStreamRequestType {
  51   MEDIA_DEVICE_ACCESS = 0,
  52   MEDIA_GENERATE_STREAM,
  53   MEDIA_ENUMERATE_DEVICES,
  54   MEDIA_OPEN_DEVICE  // Only used in requests made by Pepper.
  55 };
  56
  57 // Facing mode for video capture.
  58 enum VideoFacingMode {
  59   MEDIA_VIDEO_FACING_NONE = 0,
  60   MEDIA_VIDEO_FACING_USER,
  61   MEDIA_VIDEO_FACING_ENVIRONMENT,
  62   MEDIA_VIDEO_FACING_LEFT,
  63   MEDIA_VIDEO_FACING_RIGHT,
  64
  65   NUM_MEDIA_VIDEO_FACING_MODE
  66 };
  67
  68 enum MediaStreamRequestResult {
  69   MEDIA_DEVICE_OK = 0,
  70   MEDIA_DEVICE_PERMISSION_DENIED,
  71   MEDIA_DEVICE_PERMISSION_DISMISSED,
  72   MEDIA_DEVICE_INVALID_STATE,
  73   MEDIA_DEVICE_NO_HARDWARE,
  74   MEDIA_DEVICE_INVALID_SECURITY_ORIGIN,
  75   MEDIA_DEVICE_TAB_CAPTURE_FAILURE,
  76   MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE,
  77   MEDIA_DEVICE_CAPTURE_FAILURE,
  78   MEDIA_DEVICE_TRACK_START_FAILURE,
  79
  80   NUM_MEDIA_REQUEST_RESULTS
  81 };
  82
  83 // Convenience predicates to determine whether the given type represents some
  84 // audio or some video device.
  85 CONTENT_EXPORT bool IsAudioInputMediaType(MediaStreamType type);
  86 CONTENT_EXPORT bool IsVideoMediaType(MediaStreamType type);
  87
  88 // TODO(xians): Change the structs to classes.
  89 // Represents one device in a request for media stream(s).
  90 struct CONTENT_EXPORT MediaStreamDevice {
  91   MediaStreamDevice();
  92
  93   MediaStreamDevice(
  94       MediaStreamType type,
  95       const std::string& id,
  96       const std::string& name);
  97
  98   MediaStreamDevice(
  99       MediaStreamType type,
 100       const std::string& id,
 101       const std::string& name,
 102       int sample_rate,
 103       int channel_layout,
 104       int frames_per_buffer);
 105
 106   ~MediaStreamDevice();
 107
 108   bool IsEqual(const MediaStreamDevice& second) const;
 109
 110   // The device's type.
 111   MediaStreamType type;
 112
 113   // The device's unique ID.
 114   std::string id;
 115
 116   // The facing mode for video capture device.
 117   VideoFacingMode video_facing;
 118
 119   // The device id of a matched output device if any (otherwise empty).
 120   // Only applicable to audio devices.
 121   std::string matched_output_device_id;
 122
 123   // The device's "friendly" name. Not guaranteed to be unique.
 124   std::string name;
 125
 126   // Contains properties that match directly with those with the same name
 127   // in media::AudioParameters.
 128   struct AudioDeviceParameters {
 129     AudioDeviceParameters()
 130         : sample_rate(), channel_layout(), frames_per_buffer(), effects() {
 131     }
 132
 133     AudioDeviceParameters(int sample_rate, int channel_layout,
 134         int frames_per_buffer)
 135         : sample_rate(sample_rate),
 136           channel_layout(channel_layout),
 137           frames_per_buffer(frames_per_buffer),
 138           effects() {
 139     }
 140
 141     // Preferred sample rate in samples per second for the device.
 142     int sample_rate;
 143
 144     // Preferred channel configuration for the device.
 145     // TODO(henrika): ideally, we would like to use media::ChannelLayout here
 146     // but including media/base/channel_layout.h violates checkdeps rules.
 147     int channel_layout;
 148
 149     // Preferred number of frames per buffer for the device.  This is filled
 150     // in on the browser side and can be used by the renderer to match the
 151     // expected browser side settings and avoid unnecessary buffering.
 152     // See media::AudioParameters for more.
 153     int frames_per_buffer;
 154
 155     // See media::AudioParameters::PlatformEffectsMask.
 156     int effects;
 157   };
 158
 159   // These below two member variables are valid only when the type of device is
 160   // audio (i.e. IsAudioInputMediaType returns true).
 161
 162   // Contains the device properties of the capture device.
 163   AudioDeviceParameters input;
 164
 165   // If the capture device has an associated output device (e.g. headphones),
 166   // this will contain the properties for the output device.  If no such device
 167   // exists (e.g. webcam w/mic), then the value of this member will be all
 168   // zeros.
 169   AudioDeviceParameters matched_output;
 170 };
 171
 172 class CONTENT_EXPORT MediaStreamDevices
 173     : public std::vector<MediaStreamDevice> {
 174  public:
 175   MediaStreamDevices();
 176   MediaStreamDevices(size_t count, const MediaStreamDevice& value);
 177
 178   // Looks for a MediaStreamDevice based on its ID.
 179   // Returns NULL if not found.
 180   const MediaStreamDevice* FindById(const std::string& device_id) const;
 181 };
 182
 183 typedef std::map<MediaStreamType, MediaStreamDevices> MediaStreamDeviceMap;
 184
 185 // Represents a request for media streams (audio/video).
 186 // TODO(vrk): Decouple MediaStreamDevice from this header file so that
 187 // media_stream_options.h no longer depends on this file.
 188 // TODO(vrk,justinlin,wjia): Figure out a way to share this code cleanly between
 189 // vanilla WebRTC, Tab Capture, and Pepper Video Capture. Right now there is
 190 // Tab-only stuff and Pepper-only stuff being passed around to all clients,
 191 // which is icky.
 192 struct CONTENT_EXPORT MediaStreamRequest {
 193   MediaStreamRequest(
 194       int render_process_id,
 195       int render_view_id,
 196       int page_request_id,
 197       const GURL& security_origin,
 198       bool user_gesture,
 199       MediaStreamRequestType request_type,
 200       const std::string& requested_audio_device_id,
 201       const std::string& requested_video_device_id,
 202       MediaStreamType audio_type,
 203       MediaStreamType video_type);
 204
 205   ~MediaStreamRequest();
 206
 207   // This is the render process id for the renderer associated with generating
 208   // frames for a MediaStream. Any indicators associated with a capture will be
 209   // displayed for this renderer.
 210   int render_process_id;
 211
 212   // This is the render view id for the renderer associated with generating
 213   // frames for a MediaStream. Any indicators associated with a capture will be
 214   // displayed for this renderer.
 215   int render_view_id;
 216
 217   // The unique id combined with render_process_id and render_view_id for
 218   // identifying this request. This is used for cancelling request.
 219   int page_request_id;
 220
 221   // Used by tab capture.
 222   std::string tab_capture_device_id;
 223
 224   // The WebKit security origin for the current request (e.g. "html5rocks.com").
 225   GURL security_origin;
 226
 227   // Set to true if the call was made in the context of a user gesture.
 228   bool user_gesture;
 229
 230   // Stores the type of request that was made to the media controller. Right now
 231   // this is only used to distinguish between WebRTC and Pepper requests, as the
 232   // latter should not be subject to user approval but only to policy check.
 233   // Pepper requests are signified by the |MEDIA_OPEN_DEVICE| value.
 234   MediaStreamRequestType request_type;
 235
 236   // Stores the requested raw device id for physical audio or video devices.
 237   std::string requested_audio_device_id;
 238   std::string requested_video_device_id;
 239
 240   // Flag to indicate if the request contains audio.
 241   MediaStreamType audio_type;
 242
 243   // Flag to indicate if the request contains video.
 244   MediaStreamType video_type;
 245 };
 246
 247 // Interface used by the content layer to notify chrome about changes in the
 248 // state of a media stream. Instances of this class are passed to content layer
 249 // when MediaStream access is approved using MediaResponseCallback.
 250 class MediaStreamUI {
 251  public:
 252   virtual ~MediaStreamUI() {}
 253
 254   // Called when MediaStream capturing is started. Chrome layer can call |stop|
 255   // to stop the stream. Returns the platform-dependent window ID for the UI, or
 256   // 0 if not applicable.
 257   virtual gfx::NativeViewId OnStarted(const base::Closure& stop) = 0;
 258 };
 259
 260 // Callback used return results of media access requests.
 261 typedef base::Callback<void(
 262     const MediaStreamDevices& devices,
 263     content::MediaStreamRequestResult result,
 264     scoped_ptr<MediaStreamUI> ui)> MediaResponseCallback;
 265
 266 }  // namespace content
 267
 268 #endif  // CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_