Implement a salt for MediaSource IDs that can be cleared by a user.

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 @@
 class AudioManager;
 }
 
 namespace content {
 
 class AudioInputDeviceManager;
 class FakeMediaStreamUIProxy;
 class MediaStreamDeviceSettings;
 class MediaStreamRequester;
 class MediaStreamUIProxy;
+class ResourceContext;
 class VideoCaptureManager;
 
 // MediaStreamManager is used to generate and close new media devices, not to
 // start the media flow. The classes requesting new media streams are answered
 // using MediaStreamRequester.
 class CONTENT_EXPORT MediaStreamManager
     : public MediaStreamProviderListener,
       public base::MessageLoop::DestructionObserver,
       public base::SystemMonitor::DevicesChangedObserver {
  public:
@@ skipping 25 matching lines @@
       const GURL& 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_view_id| refer to
   // the view where the infobar will appear to the user.
   std::string GenerateStream(MediaStreamRequester* requester,
                              int render_process_id,
                              int render_view_id,
+                             ResourceContext* rc,
                              int page_request_id,
                              const StreamOptions& components,
                              const GURL& security_origin);
 
   virtual void CancelRequest(const std::string& label);
   void CancelAllRequests(int render_process_id);
 
   // Closes the stream device for a certain render view. The stream must have
   // been opened by a call to GenerateStream.
   void StopStreamDevice(int render_process_id,
                         int render_view_id,
                         const std::string& device_id);
 
   // Gets a list of devices of |type|, which must be MEDIA_DEVICE_AUDIO_CAPTURE
   // or MEDIA_DEVICE_VIDEO_CAPTURE.
   // The request is identified using the string returned to the caller.
   // 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_view_id,
+                                       ResourceContext* rc,
                                        int page_request_id,
                                        MediaStreamType type,
                                        const GURL& 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.
   std::string OpenDevice(MediaStreamRequester* requester,
                          int render_process_id,
                          int render_view_id,
+                         ResourceContext* rc,
                          int page_request_id,
                          const std::string& device_id,
                          MediaStreamType type,
                          const GURL& security_origin);
 
   // Implements MediaStreamProviderListener.
   virtual void Opened(MediaStreamType stream_type,
                       int capture_session_id) OVERRIDE;
   virtual void Closed(MediaStreamType stream_type,
                       int capture_session_id) OVERRIDE;
@@ skipping 89 matching lines @@
   MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type);
   void StartEnumeration(DeviceRequest* request);
   std::string AddRequest(DeviceRequest* request);
   DeviceRequest* FindRequest(const std::string& label);
   void DeleteRequest(const std::string& label);
   void ClearEnumerationCache(EnumerationCache* cache);
   void PostRequestToUI(const std::string& label);
   void HandleRequest(const std::string& label);
   bool SetupTabCaptureRequest(DeviceRequest* request);
   bool SetupScreenCaptureRequest(DeviceRequest* request);
-  // Returns true if a device with |device_id| has already been requested by
-  // |render_process_id| and |render_view_id| of type |type|. If it has been
-  // requested, |device_info| contain information about the device.
-  bool FindExistingRequestedDeviceInfo(int render_process_id,
-                                       int render_view_id,
-                                       const GURL& security_origin,
-                                       MediaStreamRequestType type,
-                                       const std::string& device_id,
-                                       MediaStreamType device_type,
-                                       StreamDeviceInfo* device_info,
-                                       MediaRequestState* request_state) const;
+  // Returns true if a device with |device_id| has already been requested with
+  // a render procecss_id and render_view_id and type equal to the the values
+  // in |request|. If it has been requested, |device_info| contain information
+  // about the device.
+  bool FindExistingRequestedDeviceInfo(
+      const DeviceRequest* new_request,
+      const MediaStreamDevice& new_device_info,
+      StreamDeviceInfo* existing_device_info,
+      MediaRequestState* existing_request_state) const;
 
   void FinalizeGenerateStream(const std::string& label,
                               DeviceRequest* request);
   void FinalizeRequestFailed(const std::string& label,
                              DeviceRequest* request);
   void FinalizeOpenDevice(const std::string& label,
                           DeviceRequest* request);
   void FinalizeMediaAccessRequest(const std::string& label,
                                   DeviceRequest* request,
                                   const MediaStreamDevices& devices);
   void FinalizeEnumerateDevices(const std::string& label,
                                 DeviceRequest* request);
 
   // Helpers to start and stop monitoring devices.
   void StartMonitoring();
   void StopMonitoring();
 
-  bool TranslateRequestedSourceIdToDeviceId(MediaStreamRequest* request);
-  void TranslateDeviceIdToSourceId(const MediaStreamRequest& request,
+  bool TranslateRequestedSourceIdToDeviceId(DeviceRequest* request);
+  void TranslateDeviceIdToSourceId(DeviceRequest* request,
                                    MediaStreamDevice* device);
 
   // 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,
+      ResourceContext* rc,
       const GURL& security_origin,
       const std::string& source_id,
       std::string* device_id);
 
   // Device thread shared by VideoCaptureManager and AudioInputDeviceManager.
   scoped_ptr<base::Thread> device_thread_;
 
   media::AudioManager* const audio_manager_;  // not owned
   scoped_refptr<AudioInputDeviceManager> audio_input_device_manager_;
   scoped_refptr<VideoCaptureManager> video_capture_manager_;
@@ skipping 24 matching lines @@
 
   bool use_fake_ui_;
   scoped_ptr<FakeMediaStreamUIProxy> fake_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_