Make default media device ID salts random by default

content/browser/renderer_host/media/media_stream_dispatcher_host.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_dispatcher_host.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "url/gurl.h"
 
 namespace content {
 
 MediaStreamDispatcherHost::MediaStreamDispatcherHost(
     int render_process_id,
-    const ResourceContext::SaltCallback& salt_callback,
+    const std::string& salt,
     MediaStreamManager* media_stream_manager,
     bool use_fake_ui)
     : BrowserMessageFilter(MediaStreamMsgStart),
       render_process_id_(render_process_id),
-      salt_callback_(salt_callback),
+      salt_(salt),
       media_stream_manager_(media_stream_manager),
       use_fake_ui_(use_fake_ui),
       weak_factory_(this) {}
 
 void MediaStreamDispatcherHost::StreamGenerated(
     int render_frame_id,
     int page_request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_devices,
     const StreamDeviceInfoArray& video_devices) {
@@ skipping 121 matching lines @@
   DVLOG(1) << "MediaStreamDispatcherHost::OnGenerateStream(" << render_frame_id
            << ", " << page_request_id << ", ["
            << " audio:" << controls.audio.requested
            << " video:" << controls.video.requested << " ], " << security_origin
            << ", " << user_gesture << ")";
 
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
   media_stream_manager_->GenerateStream(
-      this, render_process_id_, render_frame_id, salt_callback_,
-      page_request_id, controls, security_origin, user_gesture);
+      this, render_process_id_, render_frame_id, salt_, page_request_id,
+      controls, security_origin, user_gesture);
 }
 
 void MediaStreamDispatcherHost::OnCancelGenerateStream(int render_frame_id,
                                                        int page_request_id) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelGenerateStream("
            << render_frame_id << ", "
            << page_request_id << ")";
   media_stream_manager_->CancelRequest(render_process_id_, render_frame_id,
                                        page_request_id);
 }
@@ skipping 14 matching lines @@
     MediaStreamType type,
     const url::Origin& security_origin) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
            << render_frame_id << ", " << page_request_id << ", " << type << ", "
            << security_origin << ")";
 
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
   media_stream_manager_->EnumerateDevices(
-      this, render_process_id_, render_frame_id, salt_callback_,
-      page_request_id, type, security_origin);
+      this, render_process_id_, render_frame_id, salt_, page_request_id, type,
+      security_origin);
 }
 
 void MediaStreamDispatcherHost::OnCancelEnumerateDevices(
     int render_frame_id,
     int page_request_id) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCancelEnumerateDevices("
            << render_frame_id << ", "
            << page_request_id << ")";
   media_stream_manager_->CancelRequest(render_process_id_, render_frame_id,
                                        page_request_id);
 }
 
 void MediaStreamDispatcherHost::OnOpenDevice(
     int render_frame_id,
     int page_request_id,
     const std::string& device_id,
     MediaStreamType type,
     const url::Origin& security_origin) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnOpenDevice(" << render_frame_id
            << ", " << page_request_id << ", device_id: " << device_id.c_str()
            << ", type: " << type << ", " << security_origin << ")";
 
   if (!MediaStreamManager::IsOriginAllowed(render_process_id_, security_origin))
     return;
 
-  media_stream_manager_->OpenDevice(
-      this, render_process_id_, render_frame_id, salt_callback_,
-      page_request_id, device_id, type, security_origin);
+  media_stream_manager_->OpenDevice(this, render_process_id_, render_frame_id,
+                                    salt_, page_request_id, device_id, type,
+                                    security_origin);
 }
 
 void MediaStreamDispatcherHost::OnCloseDevice(
     int render_frame_id,
     const std::string& label) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnCloseDevice("
            << render_frame_id << ", "
            << label << ")";
 
   media_stream_manager_->CancelRequest(label);
@@ skipping 59 matching lines @@
 void MediaStreamDispatcherHost::OnSetCapturingLinkSecured(int session_id,
                                                           MediaStreamType type,
                                                           bool is_secure) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->SetCapturingLinkSecured(render_process_id_, session_id,
                                                  type, is_secure);
 }
 
 }  // namespace content