Do not hash default and communications media device ID

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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/run_loop.h"
@@ skipping 32 matching lines @@
 #elif defined(OS_MACOSX)
 typedef media::AudioManagerMac AudioManagerPlatform;
 #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);
+}
+
+}  // namespace
 
 // This class mocks the audio manager and overrides the
 // GetAudioInputDeviceNames() method to ensure that we can run our tests on
 // the buildbots. media::AudioManagerBase
 class MockAudioManager : public AudioManagerPlatform {
  public:
   MockAudioManager() : AudioManagerPlatform(&fake_audio_log_factory_) {}
   ~MockAudioManager() override {}
 
   void GetAudioInputDeviceNames(
@@ skipping 112 matching lines @@
   std::string label1 = MakeMediaAccessRequest(0);
   std::string label2 = MakeMediaAccessRequest(1);
   media_stream_manager_->CancelRequest(label1);
 
   // Expecting the callback from the second request will be triggered and
   // quit the test.
   EXPECT_CALL(*this, Response(1));
   run_loop_.Run();
 }
 
+TEST_F(MediaStreamManagerTest, DeviceID) {
+  GURL security_origin("http://localhost");
+  const std::string unique_default_id(
+      media::AudioManagerBase::kDefaultDeviceId);
+  const std::string hashed_default_id =
+      MediaStreamManager::GetHMACForMediaDeviceID(
+          GetMockSaltCallback(), security_origin, unique_default_id);
+  EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
+      GetMockSaltCallback(), security_origin, hashed_default_id,
+      unique_default_id));
+  EXPECT_EQ(unique_default_id, hashed_default_id);
+
+  const std::string unique_communications_id(
+      media::AudioManagerBase::kCommunicationsDeviceId);
+  const std::string hashed_communications_id =
+      MediaStreamManager::GetHMACForMediaDeviceID(
+          GetMockSaltCallback(), security_origin, unique_communications_id);
+  EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
+      GetMockSaltCallback(), 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);
+  EXPECT_TRUE(MediaStreamManager::DoesMediaDeviceIDMatchHMAC(
+      GetMockSaltCallback(), 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((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
+}
+
 }  // namespace content