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

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 18 matching lines @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/system_monitor/system_monitor.h"
 #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 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.
   void GenerateStream(MediaStreamRequester* requester,
                       int render_process_id,
                       int render_view_id,
-                      ResourceContext* rc,
+                      const ResourceContext::SaltCallback& sc,
                       int page_request_id,
                       const StreamOptions& components,
                       const GURL& security_origin);
 
   void CancelRequest(int render_process_id,
                      int render_view_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|.
   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);
+                                       int render_process_id,
+                                       int render_view_id,
+                                       const ResourceContext::SaltCallback& sc,
+                                       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.
   void 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);
 
   // Called by UI to make sure the device monitor is started so that UI receive
   // notifications about device changes.
   void EnsureDeviceMonitorStarted();
 
   // Implements MediaStreamProviderListener.
@@ skipping 171 matching lines @@
   // corresponding render processes are in |render_process_ids|, to be used by
   // the webrtcLoggingPrivate API if requested.
   void AddLogMessageOnUIThread(const std::set<int>& render_process_ids,
                                const std::string& message);
 
   // 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 ResourceContext::SaltCallback& rc,
       const GURL& security_origin,
       const std::string& source_id,
       std::string* device_id) const;
 
   // Task runner shared by VideoCaptureManager and AudioInputDeviceManager.
   // Note: Enumeration tasks may take seconds to complete so must never be run
   // on any of the BrowserThreads (UI, IO, etc).  See http://crbug.com/256945.
   scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
 
   media::AudioManager* const audio_manager_;  // not owned
@@ skipping 21 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_