[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

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 63 matching lines @@
   virtual ~MediaStreamManager();
 
   // Used to access VideoCaptureManager.
   VideoCaptureManager* video_capture_manager();
 
   // Used to access AudioInputDeviceManager.
   AudioInputDeviceManager* audio_input_device_manager();
 
   // Creates a new media access request which is identified by a unique string
   // that's returned to the caller. This will trigger the infobar and ask users
-  // for access to the device. |render_process_id| and |render_view_id| refer
-  // to the view where the infobar will appear to the user. |callback| is
+  // 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_view_id,
+      int render_frame_id,
       int page_request_id,
       const StreamOptions& options,
       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.
+  // 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_view_id,
+                      int render_frame_id,
                       const ResourceContext::SaltCallback& sc,
                       int page_request_id,
                       const StreamOptions& components,
                       const GURL& security_origin,
                       bool user_gesture);
 
   void CancelRequest(int render_process_id,
-                     int render_view_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|.
   void CancelAllRequests(int render_process_id);
 
-  // Closes the stream device for a certain render view. The stream must have
+  // Closes the stream device for a certain render frame. The stream must have
   // been opened by a call to GenerateStream.
   void StopStreamDevice(int render_process_id,
-                        int render_view_id,
+                        int render_frame_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.
   // If |have_permission| is false, we remove the device label from the result.
   virtual std::string EnumerateDevices(MediaStreamRequester* requester,
                                        int render_process_id,
-                                       int render_view_id,
+                                       int render_frame_id,
                                        const ResourceContext::SaltCallback& sc,
                                        int page_request_id,
                                        MediaStreamType type,
                                        const GURL& security_origin,
                                        bool have_permission);
 
   // 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,
+                  int render_frame_id,
                   const ResourceContext::SaltCallback& sc,
                   int page_request_id,
                   const std::string& device_id,
                   MediaStreamType type,
                   const GURL& 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(
@@ skipping 136 matching lines @@
   // StreamOptions::Constraints for requested tab capture IDs.
   bool SetupTabCaptureRequest(DeviceRequest* request);
   // Prepare |request| of type MEDIA_LOOPBACK_AUDIO_CAPTURE and/or
   // MEDIA_DESKTOP_VIDEO_CAPTURE for being posted to the UI by parsing
   // StreamOptions::Constraints for the requested desktop ID.
   bool SetupScreenCaptureRequest(DeviceRequest* request);
   // Called when a request has been setup and devices have been enumerated if
   // needed.
   void PostRequestToUI(const std::string& label, DeviceRequest* request);
   // 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
+  // a render procecss_id and render_frame_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);
@@ skipping 78 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_