Allow retrieval of media device ID salt even after ResourceContext has gone away.

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 127 matching lines @@
     output_string += "No devices found.";
   } else {
     for (StreamDeviceInfoArray::const_iterator it = devices.begin();
          it != devices.end(); ++it) {
       output_string += "  " + it->device.name + "\n";
     }
   }
   return output_string;
 }
 
+// Needed for MediaStreamManager::GenerateStream below.
+std::string ReturnEmptySalt() {
+  return std::string();
+}
+
 }  // namespace
 
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
 // available devices or open one or more devices.
 // TODO(perkj): MediaStreamManager still needs refactoring. I propose we create
 // several subclasses of DeviceRequest and move some of the responsibility of
 // the MediaStreamManager to the subclasses to get rid of the way too many if
 // statements in MediaStreamManager.
 class MediaStreamManager::DeviceRequest {
  public:
   DeviceRequest(MediaStreamRequester* requester,
                 int requesting_process_id,
                 int requesting_view_id,
                 int page_request_id,
                 const GURL& security_origin,
                 MediaStreamRequestType request_type,
                 const StreamOptions& options,
-                ResourceContext* resource_context)
+                const ResourceContext::SaltCallback& salt_callback)
       : requester(requester),
         requesting_process_id(requesting_process_id),
         requesting_view_id(requesting_view_id),
         page_request_id(page_request_id),
         security_origin(security_origin),
         request_type(request_type),
         options(options),
-        resource_context(resource_context),
+        salt_callback(salt_callback),
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED),
         audio_type_(MEDIA_NO_SERVICE),
         video_type_(MEDIA_NO_SERVICE) {
   }
 
   ~DeviceRequest() {}
 
   void SetAudioType(MediaStreamType audio_type) {
     DCHECK(IsAudioMediaType(audio_type) || audio_type == MEDIA_NO_SERVICE);
     audio_type_ = audio_type;
@@ skipping 99 matching lines @@
 
   // An ID the render view provided to identify this request.
   const int page_request_id;
 
   const GURL security_origin;
 
   const MediaStreamRequestType request_type;
 
   const StreamOptions options;
 
-  ResourceContext* resource_context;
+  ResourceContext::SaltCallback salt_callback;
 
   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;
 
@@ skipping 67 matching lines @@
 
   // 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,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              MEDIA_DEVICE_ACCESS,
                                              options,
-                                             NULL);
+                                             base::Bind(&ReturnEmptySalt));
 
   const std::string& label = AddRequest(request);
 
   request->callback = callback;
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::SetupRequest,
                  base::Unretained(this), label));
   return label;
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
-                                        ResourceContext* rc,
+                                        const ResourceContext::SaltCallback& sc,
                                         int page_request_id,
                                         const StreamOptions& options,
                                         const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "GenerateStream()";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeUIForMediaStream)) {
     UseFakeUI(scoped_ptr<FakeMediaStreamUIProxy>());
   }
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              MEDIA_GENERATE_STREAM,
                                              options,
-                                             rc);
+                                             sc);
 
   const std::string& label = AddRequest(request);
 
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
@@ skipping 155 matching lines @@
         request_it->second->SetState(type, MEDIA_REQUEST_STATE_CLOSING);
       }
     }
   }
 }
 
 std::string MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
-    ResourceContext* rc,
+    const ResourceContext::SaltCallback& sc,
     int page_request_id,
     MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(requester);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              MEDIA_ENUMERATE_DEVICES,
                                              StreamOptions(),
-                                             rc);
+                                             sc);
   if (IsAudioMediaType(type))
     request->SetAudioType(type);
   else if (IsVideoMediaType(type))
     request->SetVideoType(type);
 
   const std::string& label = AddRequest(request);
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
@@ skipping 30 matching lines @@
     FinalizeEnumerateDevices(label, request);
   } else {
     StartEnumeration(request);
   }
   DVLOG(1) << "Enumerate Devices ({label = " << label <<  "})";
 }
 
 void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
                                     int render_process_id,
                                     int render_view_id,
-                                    ResourceContext* rc,
+                                    const ResourceContext::SaltCallback& sc,
                                     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);
   DVLOG(1) << "OpenDevice ({page_request_id = " << page_request_id <<  "})";
   StreamOptions options;
   if (IsAudioMediaType(type)) {
     options.audio_requested = true;
     options.mandatory_audio.push_back(
         StreamOptions::Constraint(kMediaStreamSourceInfoId, device_id));
   } else if (IsVideoMediaType(type)) {
     options.video_requested = true;
     options.mandatory_video.push_back(
         StreamOptions::Constraint(kMediaStreamSourceInfoId, device_id));
   } else {
     NOTREACHED();
   }
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              MEDIA_OPEN_DEVICE,
                                              options,
-                                             rc);
+                                             sc);
 
   const std::string& label = AddRequest(request);
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::SetupRequest,
                  base::Unretained(this), label));
 }
 
 void MediaStreamManager::EnsureDeviceMonitorStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   StartMonitoring();
 }
 
 void MediaStreamManager::StopRemovedDevices(
     const StreamDeviceInfoArray& old_devices,
     const StreamDeviceInfoArray& new_devices) {
   DVLOG(1) << "StopRemovedDevices("
            << "{#old_devices = " << old_devices.size() <<  "} "
            << "{#new_devices = " << new_devices.size() << "})";
   for (StreamDeviceInfoArray::const_iterator old_dev_it = old_devices.begin();
        old_dev_it != old_devices.end(); ++old_dev_it) {
     bool device_found = false;
-    for (StreamDeviceInfoArray::const_iterator new_dev_it = new_devices.begin();
-         new_dev_it != new_devices.end(); ++new_dev_it) {
+    StreamDeviceInfoArray::const_iterator new_dev_it = new_devices.begin();
+    for (; new_dev_it != new_devices.end(); ++new_dev_it) {
       if (old_dev_it->device.id == new_dev_it->device.id) {
         device_found = true;
         break;
       }
     }
 
     if (!device_found) {
       // A device has been removed. We need to check if it is used by a
       // MediaStream and in that case cleanup and notify the render process.
       StopRemovedDevice(old_dev_it->device);
     }
   }
 }
 
 void MediaStreamManager::StopRemovedDevice(const MediaStreamDevice& device) {
   std::vector<int> session_ids;
   for (DeviceRequests::const_iterator it = requests_.begin();
        it != requests_.end() ; ++it) {
     const DeviceRequest* request = it->second;
     for (StreamDeviceInfoArray::const_iterator device_it =
              request->devices.begin();
          device_it != request->devices.end(); ++device_it) {
       std::string source_id = content::GetHMACForMediaDeviceID(
-          request->resource_context,
+          request->salt_callback,
           request->security_origin,
           device.id);
       if (device_it->device.id == source_id &&
           device_it->device.type == device.type) {
         session_ids.push_back(device_it->session_id);
         if (it->second->requester) {
           it->second->requester->DeviceStopped(
               it->second->requesting_view_id,
               it->first,
               *device_it);
@@ skipping 54 matching lines @@
                                       kMediaStreamSourceInfoId, &source_ids);
   if (source_ids.size() > 1) {
     LOG(ERROR) << "Only one mandatory " << kMediaStreamSourceInfoId
         << " is supported.";
     return false;
   }
   // If a specific device has been requested we need to find the real device
   // id.
   if (source_ids.size() == 1 &&
       !TranslateSourceIdToDeviceId(type,
-                                   request->resource_context,
+                                   request->salt_callback,
                                    request->security_origin,
                                    source_ids[0], device_id)) {
     LOG(WARNING) << "Invalid mandatory " << kMediaStreamSourceInfoId
                  << " = " << source_ids[0] << ".";
     return false;
   }
   // Check for optional audio sourceIDs.
   if (device_id->empty()) {
     StreamOptions::GetConstraintsByName(*optional,
                                         kMediaStreamSourceInfoId,
                                         &source_ids);
     // Find the first sourceID that translates to device. Note that only one
     // device per type can call to GenerateStream is ever opened.
     for (std::vector<std::string>::const_iterator it = source_ids.begin();
          it != source_ids.end(); ++it) {
       if (TranslateSourceIdToDeviceId(type,
-                                      request->resource_context,
+                                      request->salt_callback,
                                       request->security_origin,
                                       *it,
                                       device_id)) {
         break;
       }
     }
   }
   return true;
 }
 
 void MediaStreamManager::TranslateDeviceIdToSourceId(
     DeviceRequest* request,
     MediaStreamDevice* device) {
   if (request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
       request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
     device->id = content::GetHMACForMediaDeviceID(
-        request->resource_context,
+        request->salt_callback,
         request->security_origin,
         device->id);
   }
 }
 
 bool MediaStreamManager::TranslateSourceIdToDeviceId(
     MediaStreamType stream_type,
-    ResourceContext* rc,
+    const ResourceContext::SaltCallback& sc,
     const GURL& security_origin,
     const std::string& source_id,
     std::string* device_id) const {
   DCHECK(stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          stream_type == MEDIA_DEVICE_VIDEO_CAPTURE);
   // The source_id can be empty if the constraint is set but empty.
   if (source_id.empty())
     return false;
 
   const 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(rc, security_origin, source_id,
+    if (content::DoesMediaDeviceIDMatchHMAC(sc, 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 316 matching lines @@
 
 bool MediaStreamManager::FindExistingRequestedDeviceInfo(
     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);
 
   std::string source_id = content::GetHMACForMediaDeviceID(
-      new_request.resource_context,
+      new_request.salt_callback,
       new_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 == new_request.requesting_process_id &&
         request->requesting_view_id == new_request.requesting_view_id &&
         request->request_type == new_request.request_type) {
       for (StreamDeviceInfoArray::const_iterator device_it =
@@ skipping 581 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