Make default media device ID salts random by default

content/browser/renderer_host/media/media_stream_manager_unittest.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 <stddef.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 42 matching lines @@
 #elif defined(OS_WIN)
 typedef media::AudioManagerWin AudioManagerPlatform;
 #elif defined(OS_ANDROID)
 typedef media::AudioManagerAndroid AudioManagerPlatform;
 #else
 typedef media::FakeAudioManager AudioManagerPlatform;
 #endif
 
 namespace {
 
-std::string ReturnMockSalt() {
-  return std::string();
-}
-
-ResourceContext::SaltCallback GetMockSaltCallback() {
-  return base::Bind(&ReturnMockSalt);
-}
+const char kMockSalt[] = "";
 
 // This class mocks the audio manager and overrides some methods to ensure that
 // we can run our tests on the buildbots.
 class MockAudioManager : public AudioManagerPlatform {
  public:
   MockAudioManager()
       : AudioManagerPlatform(base::ThreadTaskRunnerHandle::Get(),
                              base::ThreadTaskRunnerHandle::Get(),
                              &fake_audio_log_factory_),
         num_output_devices_(2),
@@ skipping 229 matching lines @@
   // quit the test.
   EXPECT_CALL(*this, Response(1));
   run_loop_.Run();
 }
 
 TEST_F(MediaStreamManagerTest, DeviceID) {
   url::Origin security_origin(GURL("http://localhost"));
   const std::string unique_default_id(
       media::AudioDeviceDescription::kDefaultDeviceId);
   const std::string hashed_default_id =
-      MediaStreamManager::GetHMACForMediaDeviceID(
-          GetMockSaltCallback(), security_origin, unique_default_id);
+      MediaStreamManager::GetHMACForMediaDeviceID(kMockSalt, security_origin,
+                                                  unique_default_id);
   EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
-      GetMockSaltCallback(), security_origin, hashed_default_id,
-      unique_default_id));
+      kMockSalt, security_origin, hashed_default_id, unique_default_id));
   EXPECT_EQ(unique_default_id, hashed_default_id);
 
   const std::string unique_communications_id(
       media::AudioDeviceDescription::kCommunicationsDeviceId);
   const std::string hashed_communications_id =
-      MediaStreamManager::GetHMACForMediaDeviceID(
-          GetMockSaltCallback(), security_origin, unique_communications_id);
+      MediaStreamManager::GetHMACForMediaDeviceID(kMockSalt, security_origin,
+                                                  unique_communications_id);
   EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
-      GetMockSaltCallback(), security_origin, hashed_communications_id,
+      kMockSalt, security_origin, hashed_communications_id,
       unique_communications_id));
   EXPECT_EQ(unique_communications_id, hashed_communications_id);
 
   const std::string unique_other_id("other-unique-id");
   const std::string hashed_other_id =
-      MediaStreamManager::GetHMACForMediaDeviceID(
-          GetMockSaltCallback(), security_origin, unique_other_id);
+      MediaStreamManager::GetHMACForMediaDeviceID(kMockSalt, security_origin,
+                                                  unique_other_id);
   EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
-      GetMockSaltCallback(), security_origin, hashed_other_id,
-      unique_other_id));
+      kMockSalt, security_origin, hashed_other_id, unique_other_id));
   EXPECT_NE(unique_other_id, hashed_other_id);
   EXPECT_EQ(hashed_other_id.size(), 64U);
   for (const char& c : hashed_other_id)
     EXPECT_TRUE(base::IsAsciiDigit(c) || (c >= 'a' && c <= 'f'));
 }
 
 TEST_F(MediaStreamManagerTest, EnumerationOutputDevices) {
   for (size_t num_devices = 0; num_devices < 3; num_devices++) {
     audio_manager_->SetNumAudioOutputDevices(num_devices);
     base::RunLoop run_loop;
     MockMediaStreamRequester requester(media_stream_manager_.get(), &run_loop,
                                        num_devices == 0 ? 0 : num_devices + 1,
                                        nullptr);
     const int render_process_id = 1;
     const int render_frame_id = 1;
     const int page_request_id = 1;
     const url::Origin security_origin(GURL("http://localhost"));
     EXPECT_CALL(requester,
                 MockDevicesEnumerated(render_frame_id, page_request_id, _, _));
     std::string label = media_stream_manager_->EnumerateDevices(
-        &requester, render_process_id, render_frame_id, GetMockSaltCallback(),
+        &requester, render_process_id, render_frame_id, kMockSalt,
         page_request_id, MEDIA_DEVICE_AUDIO_OUTPUT, security_origin);
     run_loop.Run();
     // CancelRequest is necessary for enumeration requests.
     media_stream_manager_->CancelRequest(label);
   }
 }
 
 TEST_F(MediaStreamManagerTest, NotifyDeviceChanges) {
   const int render_process_id = 1;
   const int render_frame_id = 1;
   const int page_request_id = 1;
   const url::Origin security_origin(GURL("http://localhost"));
 
   // Check that device change notifications are received
   {
     // First run an enumeration to warm up the cache
     base::RunLoop run_loop_enumeration;
     base::RunLoop run_loop_device_change;
     MockMediaStreamRequester requester(media_stream_manager_.get(),
                                        &run_loop_enumeration, 3,
                                        &run_loop_device_change);
     audio_manager_->SetNumAudioInputDevices(2);
     requester.SubscribeToDeviceChangeNotifications();
 
     EXPECT_CALL(requester,
                 MockDevicesEnumerated(render_frame_id, page_request_id, _, _));
     EXPECT_CALL(requester, MockDevicesChanged(_)).Times(0);
     std::string label = media_stream_manager_->EnumerateDevices(
-        &requester, render_process_id, render_frame_id, GetMockSaltCallback(),
+        &requester, render_process_id, render_frame_id, kMockSalt,
         page_request_id, MEDIA_DEVICE_AUDIO_CAPTURE, security_origin);
     run_loop_enumeration.Run();
     media_stream_manager_->CancelRequest(label);
 
     // Simulate device change
     EXPECT_CALL(requester, MockDevicesChanged(_));
     audio_manager_->SetNumAudioInputDevices(3);
     media_stream_manager_->OnDevicesChanged(
         base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
     run_loop_device_change.Run();
@@ skipping 10 matching lines @@
     // Bogus OnDeviceChange, as devices have not changed. Should not trigger
     // notification.
     EXPECT_CALL(requester, MockDevicesChanged(_)).Times(0);
     media_stream_manager_->OnDevicesChanged(
         base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
 
     // Do enumeration to be able to quit the RunLoop.
     EXPECT_CALL(requester,
                 MockDevicesEnumerated(render_frame_id, page_request_id, _, _));
     std::string label = media_stream_manager_->EnumerateDevices(
-        &requester, render_process_id, render_frame_id, GetMockSaltCallback(),
+        &requester, render_process_id, render_frame_id, kMockSalt,
         page_request_id, MEDIA_DEVICE_AUDIO_CAPTURE, security_origin);
     run_loop.Run();
     media_stream_manager_->CancelRequest(label);
   }
 }
 
 }  // namespace content