Revert of Make default media device ID salts random by default

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 101 matching lines @@
       const url::Origin& 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_frame_id| are used
   // to determine where the infobar will appear to the user.
   void GenerateStream(MediaStreamRequester* requester,
                       int render_process_id,
                       int render_frame_id,
-                      const std::string& salt,
+                      const ResourceContext::SaltCallback& sc,
                       int page_request_id,
                       const StreamControls& controls,
                       const url::Origin& security_origin,
                       bool user_gesture);
 
   void CancelRequest(int render_process_id,
                      int render_frame_id,
                      int page_request_id);
 
   // Cancel an open request identified by |label|.
@@ skipping 11 matching lines @@
   // 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_frame_id,
-                                       const std::string& salt,
+                                       const ResourceContext::SaltCallback& sc,
                                        int page_request_id,
                                        MediaStreamType type,
                                        const url::Origin& 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_frame_id,
-                  const std::string& salt,
+                  const ResourceContext::SaltCallback& sc,
                   int page_request_id,
                   const std::string& device_id,
                   MediaStreamType type,
                   const url::Origin& 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(MediaStreamType stream_type,
-                                   const std::string& salt,
+                                   const ResourceContext::SaltCallback& rc,
                                    const url::Origin& security_origin,
                                    const std::string& source_id,
                                    std::string* device_id) const;
 
   // Find |device_id| in the list of |requests_|, and returns its session id,
   // or StreamDeviceInfo::kNoId if not found.
   int VideoDeviceIdToSessionId(const std::string& device_id) const;
 
   // Called by UI to make sure the device monitor is started so that UI receive
   // notifications about device changes.
@@ skipping 49 matching lines @@
   // It is an error to try to subscribe a |subscriber| that is already
   // subscribed or to cancel the subscription of a |subscriber| that is not
   // subscribed. Also, subscribers must make sure to invoke
   // CancelDeviceChangeNotifications() before destruction. Otherwise, dangling
   // pointers and use-after-destruction problems will occur.
   void SubscribeToDeviceChangeNotifications(MediaStreamRequester* subscriber);
   void CancelDeviceChangeNotifications(MediaStreamRequester* subscriber);
 
   // Generates a hash of a device's unique ID usable by one
   // particular security origin.
-  static std::string GetHMACForMediaDeviceID(const std::string& salt,
-                                             const url::Origin& security_origin,
-                                             const std::string& raw_unique_id);
+  static std::string GetHMACForMediaDeviceID(
+      const ResourceContext::SaltCallback& sc,
+      const url::Origin& security_origin,
+      const std::string& raw_unique_id);
 
   // Convenience method to check if |device_guid| is an HMAC of
   // |raw_device_id| for |security_origin|.
-  static bool DoesMediaDeviceIDMatchHMAC(const std::string& salt,
-                                         const url::Origin& security_origin,
-                                         const std::string& device_guid,
-                                         const std::string& raw_unique_id);
+  static bool DoesMediaDeviceIDMatchHMAC(
+      const ResourceContext::SaltCallback& sc,
+      const url::Origin& security_origin,
+      const std::string& device_guid,
+      const std::string& raw_unique_id);
 
   // Returns true if the renderer process identified with |render_process_id|
   // is allowed to access |origin|.
   static bool IsOriginAllowed(int render_process_id, const url::Origin& origin);
 
   // Set whether the capturing is secure for the capturing session with given
   // |session_id|, |render_process_id|, and the MediaStreamType |type|.
   void SetCapturingLinkSecured(int render_process_id,
                                int session_id,
                                content::MediaStreamType type,
@@ skipping 131 matching lines @@
   void StartMonitoringOnUIThread();
 #endif
 
   // Picks a device ID from a list of required and alternate device IDs,
   // presented as part of a TrackControls structure.
   // Either the required device ID is picked (if present), or the first
   // valid alternate device ID.
   // Returns false if the required device ID is present and invalid.
   // Otherwise, if no valid device is found, device_id is unchanged.
   bool PickDeviceId(MediaStreamType type,
-                    const std::string& salt,
+                    const ResourceContext::SaltCallback& salt_callback,
                     const url::Origin& security_origin,
                     const TrackControls& controls,
                     std::string* device_id) const;
 
   // Finds the requested device id from request. The requested device type
   // must be MEDIA_DEVICE_AUDIO_CAPTURE or MEDIA_DEVICE_VIDEO_CAPTURE.
   bool GetRequestedDeviceCaptureId(const DeviceRequest* request,
                                    MediaStreamType type,
                                    std::string* device_id) const;
 
@@ skipping 50 matching lines @@
 
   // Objects subscribed to changes in the set of media devices.
   std::vector<MediaStreamRequester*> device_change_subscribers_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_