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

content/browser/renderer_host/media/media_stream_manager.cc

 // 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.
 
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
   return label;
 }
 
 // Helper to verify if a media stream type is part of options or not.
 static bool Requested(const MediaStreamRequest& request,
                       MediaStreamType stream_type) {
   return (request.audio_type == stream_type ||
           request.video_type == stream_type);
 }
 
-// TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 class MediaStreamManager::DeviceRequest {
  public:
   DeviceRequest(MediaStreamRequester* requester,
                 const MediaStreamRequest& request,
                 int requesting_process_id,
-                int requesting_view_id)
+                int requesting_view_id,
+                ResourceContext* resource_context)
       : requester(requester),
         request(request),
         requesting_process_id(requesting_process_id),
         requesting_view_id(requesting_view_id),
+        resource_context(resource_context),
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED) {
   }
 
   ~DeviceRequest() {}
 
   // Update the request state and notify observers.
   void SetState(MediaStreamType stream_type, MediaRequestState new_state) {
     if (stream_type == NUM_MEDIA_TYPES) {
       for (int i = MEDIA_NO_SERVICE + 1; i < NUM_MEDIA_TYPES; ++i) {
         const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
@@ skipping 39 matching lines @@
   // MediaStreamRequest::render_process_id which in the tab capture case
   // specifies the target renderer from which audio and video is captured.
   const int requesting_process_id;
 
   // The render view id that requested this stream to be generated and that
   // will receive a handle to the MediaStream. This may be different from
   // MediaStreamRequest::render_view_id which in the tab capture case
   // specifies the target renderer from which audio and video is captured.
   const int requesting_view_id;
 
+  ResourceContext* resource_context;
+
   StreamDeviceInfoArray devices;
 
   // Callback to the requester which audio/video devices have been selected.
   // It can be null if the requester has no interest to know the result.
   // Currently it is only used by |DEVICE_ACCESS| type.
   MediaStreamManager::MediaRequestResponseCallback callback;
 
   scoped_ptr<MediaStreamUIProxy> ui_proxy;
 
  private:
@@ skipping 58 matching lines @@
     int page_request_id,
     const StreamOptions& options,
     const GURL& security_origin,
     const MediaRequestResponseCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Create a new request based on options.
   MediaStreamRequest stream_request(
       render_process_id, render_view_id, page_request_id,
       security_origin, MEDIA_DEVICE_ACCESS, std::string(), std::string(),
       options.audio_type, options.video_type);
+  // TODO(perkj): The argument list with NULL parameters to DeviceRequest
+  // suggests that this is the wrong design. Can this be refactored?
   DeviceRequest* request = new DeviceRequest(NULL, stream_request,
-                                             render_process_id, render_view_id);
+                                             render_process_id, render_view_id,
+                                             NULL);
   const std::string& label = AddRequest(request);
 
   request->callback = callback;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::HandleRequest,
                  base::Unretained(this), label));
   return label;
 }
 
 std::string MediaStreamManager::GenerateStream(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
+    ResourceContext* rc,
     int page_request_id,
     const StreamOptions& options,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeDeviceForMediaStream)) {
     UseFakeDevice();
   }
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseFakeUIForMediaStream)) {
     UseFakeUI(scoped_ptr<FakeMediaStreamUIProxy>());
   }
 
   // Create a new request based on options.
   MediaStreamRequest stream_request(
       render_process_id, render_view_id, page_request_id,
       security_origin, MEDIA_GENERATE_STREAM,
       options.audio_device_id, options.video_device_id,
       options.audio_type, options.video_type);
   DeviceRequest* request = new DeviceRequest(requester, stream_request,
                                              render_process_id,
-                                             render_view_id);
+                                             render_view_id,
+                                             rc);
   const std::string& label = AddRequest(request);
 
   // Need to post a task since the requester won't have label till
   // this function returns.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::HandleRequest,
                  base::Unretained(this), label));
   return label;
 }
@@ skipping 129 matching lines @@
                                      MEDIA_REQUEST_STATE_CLOSING);
       }
     }
   }
 }
 
 std::string MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
+    ResourceContext* rc,
     int page_request_id,
     MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // When the requester is NULL, the request is made by the UI to ensure MSM
   // starts monitoring devices.
   if (!requester) {
@@ skipping 12 matching lines @@
   } else {
     NOTREACHED();
     return std::string();
   }
 
   MediaStreamRequest stream_request(
       render_process_id, render_view_id, page_request_id,
       security_origin, MEDIA_ENUMERATE_DEVICES, std::string(), std::string(),
       options.audio_type, options.video_type);
   DeviceRequest* request = new DeviceRequest(requester, stream_request,
-                                             render_process_id,
-                                             render_view_id);
+                                             render_process_id, render_view_id,
+                                             rc);
   const std::string& label = AddRequest(request);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::DoEnumerateDevices,
                  base::Unretained(this), label));
 
   return label;
 }
 
 void MediaStreamManager::DoEnumerateDevices(const std::string& label) {
@@ skipping 19 matching lines @@
     FinalizeEnumerateDevices(label, request);
   } else {
     StartEnumeration(request);
   }
 }
 
 std::string MediaStreamManager::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) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // Create a new request.
   StreamOptions options;
   if (IsAudioMediaType(type)) {
     options.audio_type = type;
     options.audio_device_id = device_id;
   } else if (IsVideoMediaType(type)) {
     options.video_type = type;
     options.video_device_id = device_id;
   } else {
     NOTREACHED();
     return std::string();
   }
 
   MediaStreamRequest stream_request(
       render_process_id, render_view_id, page_request_id,
       security_origin, MEDIA_OPEN_DEVICE, options.audio_device_id,
       options.video_device_id, options.audio_type, options.video_type);
   DeviceRequest* request = new DeviceRequest(requester, stream_request,
-                                             render_process_id,
-                                             render_view_id);
+                                             render_process_id, render_view_id,
+                                             rc);
   const std::string& label = AddRequest(request);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::HandleRequest,
                  base::Unretained(this), label));
 
   return label;
 }
 
 void MediaStreamManager::StartMonitoring() {
@@ skipping 18 matching lines @@
   DCHECK_EQ(base::MessageLoop::current(), io_loop_);
   if (monitoring_started_) {
     base::SystemMonitor::Get()->RemoveDevicesChangedObserver(this);
     monitoring_started_ = false;
     ClearEnumerationCache(&audio_enumeration_cache_);
     ClearEnumerationCache(&video_enumeration_cache_);
   }
 }
 
 bool MediaStreamManager::TranslateRequestedSourceIdToDeviceId(
-    MediaStreamRequest* request) {
+    DeviceRequest* request) {
+  MediaStreamRequest* ms_request = &request->request;
   // If a specific device has been requested we need to find the real device id.
-  if (request->audio_type == MEDIA_DEVICE_AUDIO_CAPTURE &&
-      !request->requested_audio_device_id.empty()) {
+  if (ms_request->audio_type == MEDIA_DEVICE_AUDIO_CAPTURE &&
+      !ms_request->requested_audio_device_id.empty()) {
     if (!TranslateSourceIdToDeviceId(MEDIA_DEVICE_AUDIO_CAPTURE,
-                                     request->security_origin,
-                                     request->requested_audio_device_id,
-                                     &request->requested_audio_device_id)) {
+                                     request->resource_context,
+                                     ms_request->security_origin,
+                                     ms_request->requested_audio_device_id,
+                                     &ms_request->requested_audio_device_id)) {
       // TODO(perkj): gUM should support mandatory and optional constraints.
       // Ie - if the sourceId is optional but it does not match - gUM should
       // not fail. For now we treat sourceId as a mandatory constraint.
       LOG(ERROR) << "Requested device does not exist.";
       return false;
     }
   }
 
-  if (request->video_type == MEDIA_DEVICE_VIDEO_CAPTURE &&
-      !request->requested_video_device_id.empty()) {
+  if (ms_request->video_type == MEDIA_DEVICE_VIDEO_CAPTURE &&
+      !ms_request->requested_video_device_id.empty()) {
     if (!TranslateSourceIdToDeviceId(MEDIA_DEVICE_VIDEO_CAPTURE,
-                                     request->security_origin,
-                                     request->requested_video_device_id,
-                                     &request->requested_video_device_id)) {
+                                     request->resource_context,
+                                     ms_request->security_origin,
+                                     ms_request->requested_video_device_id,
+                                     &ms_request->requested_video_device_id)) {
       // TODO(perkj): guM should support mandatory and optional constraints.
       // Ie - if the sourceId is optional but it does not match - guM should
       // not fail. For now we treat sourceId as a mandatory constraint.
       return false;
     }
   }
-  DVLOG(3) << "Requested audio device " << request->requested_audio_device_id
-           << "Requested video device " << request->requested_video_device_id;
+  DVLOG(3) << "Requested audio device "
+           << ms_request->requested_audio_device_id
+           << "Requested video device "
+           << ms_request->requested_video_device_id;
   return true;
 }
 
 void MediaStreamManager::TranslateDeviceIdToSourceId(
-    const MediaStreamRequest& request,
+    DeviceRequest* request,
     MediaStreamDevice* device) {
-  if (request.audio_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
-      request.video_type == MEDIA_DEVICE_VIDEO_CAPTURE) {
+  if (request->request.audio_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
+      request->request.video_type == MEDIA_DEVICE_VIDEO_CAPTURE) {
     device->id = content::GetHMACForMediaDeviceID(
-        request.security_origin,
+        request->resource_context,
+        request->request.security_origin,
         device->id);
     return;
   }
   return;
 }
 
 bool MediaStreamManager::TranslateSourceIdToDeviceId(
     MediaStreamType stream_type,
+    ResourceContext* rc,
     const GURL& security_origin,
     const std::string& source_id,
     std::string* device_id) {
   DCHECK(stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          stream_type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DCHECK(!source_id.empty());
 
   EnumerationCache* cache =
       stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ?
       &audio_enumeration_cache_ : &video_enumeration_cache_;
 
   // If device monitoring hasn't started, the |device_guid| is not valid.
   if (!cache->valid)
     return false;
 
   for (StreamDeviceInfoArray::const_iterator it = cache->devices.begin();
        it != cache->devices.end();
        ++it) {
-    if (content::DoesMediaDeviceIDMatchHMAC(security_origin, source_id,
+    if (content::DoesMediaDeviceIDMatchHMAC(rc, security_origin, source_id,
                                             it->device.id)) {
       *device_id = it->device.id;
       return true;
     }
   }
   return false;
 }
 
 void MediaStreamManager::ClearEnumerationCache(EnumerationCache* cache) {
   DCHECK_EQ(base::MessageLoop::current(), io_loop_);
@@ skipping 110 matching lines @@
   if (!is_web_contents_capture &&
       !is_screen_capture &&
       ((IsAudioMediaType(audio_type) && !audio_enumeration_cache_.valid) ||
        (IsVideoMediaType(video_type) && !video_enumeration_cache_.valid))) {
     // Enumerate the devices if there is no valid device lists to be used.
     StartEnumeration(request);
     return;
   }
 
   // If a specific device has been requested we need to find the real device id.
-  if (!TranslateRequestedSourceIdToDeviceId(&request->request)) {
+  if (!TranslateRequestedSourceIdToDeviceId(request)) {
     FinalizeRequestFailed(label, request);
     return;
   }
 
   // No need to do new device enumerations, post the request to UI
   // immediately.
   if (IsAudioMediaType(audio_type))
     request->SetState(audio_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
   if (IsVideoMediaType(video_type))
     request->SetState(video_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
@@ skipping 76 matching lines @@
         if (source_id == device_it->device.id) {
           return &*device_it;
         }
       }
     }
   }
   return NULL;
 }
 
 bool MediaStreamManager::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 {
-  DCHECK(device_info);
-  DCHECK(request_state);
+    const DeviceRequest& new_request,
+    const MediaStreamDevice& new_device_info,
+    StreamDeviceInfo* existing_device_info,
+    MediaRequestState* existing_request_state) const {
+  DCHECK(existing_device_info);
+  DCHECK(existing_request_state);
+
+  const MediaStreamRequest& new_ms_request = new_request.request;
 
   std::string source_id = content::GetHMACForMediaDeviceID(
-      security_origin,
-      device_id);
+      new_request.resource_context,
+      new_ms_request.security_origin,
+      new_device_info.id);
 
   for (DeviceRequests::const_iterator it = requests_.begin();
        it != requests_.end() ; ++it) {
     const DeviceRequest* request = it->second;
-    if (request->requesting_process_id == render_process_id &&
-        request->requesting_view_id == render_view_id &&
-        request->request.request_type == type) {
+    if (request->requesting_process_id == new_request.requesting_process_id &&
+        request->requesting_view_id == new_request.requesting_view_id &&
+        request->request.request_type == new_ms_request.request_type) {
       for (StreamDeviceInfoArray::const_iterator device_it =
                request->devices.begin();
            device_it != request->devices.end(); ++device_it) {
         if (device_it->device.id == source_id &&
-            device_it->device.type == device_type) {
-            *device_info = *device_it;
-            *request_state = request->state(device_it->device.type);
+            device_it->device.type == new_device_info.type) {
+            *existing_device_info = *device_it;
+            *existing_request_state = request->state(device_it->device.type);
           return true;
         }
       }
     }
   }
   return false;
 }
 
 void MediaStreamManager::FinalizeGenerateStream(const std::string& label,
                                                 DeviceRequest* request) {
@@ skipping 33 matching lines @@
 void MediaStreamManager::FinalizeOpenDevice(const std::string& label,
                                             DeviceRequest* request) {
   const StreamDeviceInfoArray& requested_devices = request->devices;
   request->requester->DeviceOpened(label, requested_devices.front());
 }
 
 void MediaStreamManager::FinalizeEnumerateDevices(const std::string& label,
                                                   DeviceRequest* request) {
   for (StreamDeviceInfoArray::iterator it = request->devices.begin();
        it != request->devices.end(); ++it) {
-    TranslateDeviceIdToSourceId(request->request, &it->device);
+    TranslateDeviceIdToSourceId(request, &it->device);
   }
   request->requester->DevicesEnumerated(label, request->devices);
 }
 
 void MediaStreamManager::FinalizeMediaAccessRequest(
     const std::string& label,
     DeviceRequest* request,
     const MediaStreamDevices& devices) {
   if (!request->callback.is_null())
     request->callback.Run(devices, request->ui_proxy.Pass());
@@ skipping 226 matching lines @@
     } else if (device_info.device.type == request->request.video_type) {
       found_video = true;
     }
 
     // If this is request for a new MediaStream, a device is only opened once
     // per render view. This is so that the permission to use a device can be
     // revoked by a single call to StopStreamDevice regardless of how many
     // MediaStreams it is being used in.
     if (request->request.request_type == MEDIA_GENERATE_STREAM) {
       MediaRequestState state;
-      if (FindExistingRequestedDeviceInfo(request->requesting_process_id,
-                                          request->requesting_view_id,
-                                          request->request.security_origin,
-                                          request->request.request_type,
-                                          device_info.device.id,
-                                          device_info.device.type,
+      if (FindExistingRequestedDeviceInfo(*request,
+                                          device_info.device,
                                           &device_info,
                                           &state)) {
         request->devices.push_back(device_info);
         request->SetState(device_info.device.type, state);
         DVLOG(1) << "HandleAccessRequestResponse - device already opened "
-            << ", {label = " << label <<  "}"
-            << ", device_id = " << device_it->id << "}";
+                 << ", {label = " << label <<  "}"
+                 << ", device_id = " << device_it->id << "}";
         continue;
       }
     }
     device_info.session_id =
         GetDeviceManager(device_info.device.type)->Open(device_info);
-    TranslateDeviceIdToSourceId(request->request, &device_info.device);
+    TranslateDeviceIdToSourceId(request, &device_info.device);
     request->devices.push_back(device_info);
 
     request->SetState(device_info.device.type, MEDIA_REQUEST_STATE_OPENING);
     DVLOG(1) << "HandleAccessRequestResponse - opening device "
              << ", {label = " << label <<  "}"
              << ", {device_id = " << device_info.device.id << "}"
              << ", {session_id = " << device_info.session_id << "}";
   }
 
   // Check whether we've received all stream types requested.
@@ skipping 133 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
 }
 
 }  // namespace content