Use url::Origin to represent security origins in MediaStream-related code.

content/browser/renderer_host/media/media_stream_manager.h

 // Copyright (c) 2012 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.
 
 // MediaStreamManager is used to open/enumerate media capture devices (video
 // supported now). Call flow:
 // 1. GenerateStream is called when a render process wants to use a capture
 //    device.
 // 2. MediaStreamManager will ask MediaStreamUIController for permission to
 //    use devices and for which device to use.
@@ skipping 33 matching lines @@
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/common/content_export.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/browser/resource_context.h"
 
 namespace media {
 class AudioManager;
 }
 
+namespace url {
+class Origin;
+}
+
 namespace content {
 
 class AudioInputDeviceManager;
 class AudioOutputDeviceEnumerator;
 class BrowserContext;
 class FakeMediaStreamUIProxy;
 class MediaStreamDeviceSettings;
 class MediaStreamRequester;
 class MediaStreamUIProxy;
 class VideoCaptureManager;
@@ skipping 34 matching lines @@
   // that's returned to the caller. This will trigger the infobar and ask users
   // for access to the device. |render_process_id| and |render_frame_id| are
   // used to determine where the infobar will appear to the user. |callback| is
   // used to send the selected device to the clients. An empty list of device
   // will be returned if the users deny the access.
   std::string MakeMediaAccessRequest(
       int render_process_id,
       int render_frame_id,
       int page_request_id,
       const StreamControls& controls,
-      const GURL& security_origin,
+      const url::Origin& security_origin,
       const MediaRequestResponseCallback& callback);
 
   // GenerateStream opens new media devices according to |components|.  It
   // creates a new request which is identified by a unique string that's
   // returned to the caller.  |render_process_id| and |render_frame_id| are used
   // to determine where the infobar will appear to the user.
   void GenerateStream(MediaStreamRequester* requester,
                       int render_process_id,
                       int render_frame_id,
                       const ResourceContext::SaltCallback& sc,
                       int page_request_id,
                       const StreamControls& controls,
-                      const GURL& security_origin,
+                      const url::Origin& security_origin,
                       bool user_gesture);
 
   void CancelRequest(int render_process_id,
                      int render_frame_id,
                      int page_request_id);
 
   // Cancel an open request identified by |label|.
   virtual void CancelRequest(const std::string& label);
 
   // Cancel all requests for the given |render_process_id|.
@@ skipping 11 matching lines @@
   // When the |requester| is NULL, MediaStreamManager will enumerate both audio
   // and video devices and also start monitoring device changes, such as
   // plug/unplug. The new device lists will be delivered via media observer to
   // MediaCaptureDevicesDispatcher.
   virtual std::string EnumerateDevices(MediaStreamRequester* requester,
                                        int render_process_id,
                                        int render_frame_id,
                                        const ResourceContext::SaltCallback& sc,
                                        int page_request_id,
                                        MediaStreamType type,
-                                       const GURL& security_origin);
+                                       const url::Origin& security_origin);
 
   // Open a device identified by |device_id|.  |type| must be either
   // MEDIA_DEVICE_AUDIO_CAPTURE or MEDIA_DEVICE_VIDEO_CAPTURE.
   // The request is identified using string returned to the caller.
   void OpenDevice(MediaStreamRequester* requester,
                   int render_process_id,
                   int render_frame_id,
                   const ResourceContext::SaltCallback& sc,
                   int page_request_id,
                   const std::string& device_id,
                   MediaStreamType type,
-                  const GURL& security_origin);
+                  const url::Origin& security_origin);
 
   // Finds and returns the device id corresponding to the given
   // |source_id|. Returns true if there was a raw device id that matched the
   // given |source_id|, false if nothing matched it.
   bool TranslateSourceIdToDeviceId(MediaStreamType stream_type,
                                    const ResourceContext::SaltCallback& rc,
-                                   const GURL& security_origin,
+                                   const url::Origin& security_origin,
                                    const std::string& source_id,
                                    std::string* device_id) const;
 
   // Called by UI to make sure the device monitor is started so that UI receive
   // notifications about device changes.
   void EnsureDeviceMonitorStarted();
 
   // Implements MediaStreamProviderListener.
   void Opened(MediaStreamType stream_type, int capture_session_id) override;
   void Closed(MediaStreamType stream_type, int capture_session_id) override;
@@ skipping 46 matching lines @@
   // subscribed. Also, subscribers must make sure to invoke
   // CancelDeviceChangeNotifications() before destruction. Otherwise, dangling
   // pointers and use-after-destruction problems will occur.
   void SubscribeToDeviceChangeNotifications(MediaStreamRequester* subscriber);
   void CancelDeviceChangeNotifications(MediaStreamRequester* subscriber);
 
   // Generates a hash of a device's unique ID usable by one
   // particular security origin.
   static std::string GetHMACForMediaDeviceID(
       const ResourceContext::SaltCallback& sc,
-      const GURL& security_origin,
+      const url::Origin& security_origin,
       const std::string& raw_unique_id);
 
   // Convenience method to check if |device_guid| is an HMAC of
   // |raw_device_id| for |security_origin|.
   static bool DoesMediaDeviceIDMatchHMAC(
       const ResourceContext::SaltCallback& sc,
-      const GURL& security_origin,
+      const url::Origin& security_origin,
       const std::string& device_guid,
       const std::string& raw_unique_id);
 
+  // Returns true if the renderer process identified with |render_process_id|
+  // is allowed to access |origin|.
+  static bool IsOriginAllowed(int render_process_id, const url::Origin& origin);
+
  private:
   // Contains all data needed to keep track of requests.
   class DeviceRequest;
 
   // Cache enumerated device list.
   struct EnumerationCache {
     EnumerationCache();
     ~EnumerationCache();
 
     bool valid;
@@ skipping 120 matching lines @@
 #endif
 
   // Picks a device ID from a list of required and alternate device IDs,
   // presented as part of a TrackControls structure.
   // Either the required device ID is picked (if present), or the first
   // valid alternate device ID.
   // Returns false if the required device ID is present and invalid.
   // Otherwise, if no valid device is found, device_id is unchanged.
   bool PickDeviceId(MediaStreamType type,
                     const ResourceContext::SaltCallback& salt_callback,
-                    const GURL& security_origin,
+                    const url::Origin& security_origin,
                     const TrackControls& controls,
                     std::string* device_id) const;
 
   // Finds the requested device id from request. The requested device type
   // must be MEDIA_DEVICE_AUDIO_CAPTURE or MEDIA_DEVICE_VIDEO_CAPTURE.
   bool GetRequestedDeviceCaptureId(const DeviceRequest* request,
                                    MediaStreamType type,
                                    std::string* device_id) const;
 
   void TranslateDeviceIdToSourceId(DeviceRequest* request,
@@ skipping 49 matching lines @@
 
   // Objects subscribed to changes in the set of media devices.
   std::vector<MediaStreamRequester*> device_change_subscribers_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_