Implement a salt for MediaSource IDs that can be cleared by a user.

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc

 // Copyright 2013 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 "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/media/webrtc_log_uploader.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "media/audio/audio_manager.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONWriter;
@@ skipping 73 matching lines @@
           FROM_HERE,
           base::Bind(&WebrtcAudioPrivateTest::GetAudioDeviceNames, this,
                      EnumerationFunc, device_names));
       enumeration_event_.Wait();
     } else {
       (audio_manager->*EnumerationFunc)(device_names);
       enumeration_event_.Signal();
     }
   }
 
+  // Synchronously (from the calling thread's point of view) retrieve the
+  // source id in the |origin| on the IO thread. On return,
+  // |source_id_in_origin| contains the id |raw_device_id| is known by in
+  // the origin.
+  void GetSourceIDInOrigin(content::ResourceContext* resource_context,
+                           GURL origin,
+                           const std::string& raw_device_id,
+                           std::string* source_id_in_origin) {
+    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::IO, FROM_HERE,
+          base::Bind(&WebrtcAudioPrivateTest::GetSourceIDInOrigin,
+                     this, resource_context, origin, raw_device_id,
+                     source_id_in_origin));
+     enumeration_event_.Wait();
+    } else {
+      *source_id_in_origin = content::GetHMACForMediaDeviceID(
+          resource_context,
+          origin,
+          raw_device_id);
+      enumeration_event_.Signal();
+    }
+  }
+
   // Event used to signal completion of enumeration.
   base::WaitableEvent enumeration_event_;
 };
 
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetSinks) {
   AudioDeviceNames devices;
   GetAudioDeviceNames(&AudioManager::GetAudioOutputDeviceNames, &devices);
 
   scoped_refptr<WebrtcAudioPrivateGetSinksFunction> function =
       new WebrtcAudioPrivateGetSinksFunction();
@@ skipping 129 matching lines @@
   // Get the list of input devices. We can cheat in the unit test and
   // run this on the main thread since nobody else will be running at
   // the same time.
   AudioDeviceNames devices;
   GetAudioDeviceNames(&AudioManager::GetAudioInputDeviceNames, &devices);
 
   // Try to get an associated sink for each source.
   for (AudioDeviceNames::const_iterator device = devices.begin();
        device != devices.end();
        ++device) {
-    std::string raw_source_id = device->unique_id;
-    VLOG(2) << "Trying to find associated sink for device " << raw_source_id;
+    scoped_refptr<WebrtcAudioPrivateGetAssociatedSinkFunction> function =
+        new WebrtcAudioPrivateGetAssociatedSinkFunction();
+
+    std::string raw_device_id = device->unique_id;
+    VLOG(2) << "Trying to find associated sink for device " << raw_device_id;
+    std::string source_id_in_origin;
     GURL origin(GURL("http://www.google.com/").GetOrigin());
-    std::string source_id_in_origin =
-        content::GetHMACForMediaDeviceID(origin, raw_source_id);
+    GetSourceIDInOrigin(profile()->GetResourceContext(),
+                        origin,
+                        raw_device_id,
+                        &source_id_in_origin);
 
     ListValue parameters;
     parameters.AppendString(origin.spec());
     parameters.AppendString(source_id_in_origin);
     std::string parameter_string;
     JSONWriter::Write(&parameters, &parameter_string);
 
-    scoped_refptr<WebrtcAudioPrivateGetAssociatedSinkFunction> function =
-        new WebrtcAudioPrivateGetAssociatedSinkFunction();
     scoped_ptr<base::Value> result(
         RunFunctionAndReturnSingleResult(function.get(),
                                          parameter_string,
                                          browser()));
     std::string result_string;
     JSONWriter::Write(result.get(), &result_string);
     VLOG(2) << "Results: " << result_string;
   }
 }
 
@@ skipping 52 matching lines @@
 
   ASSERT_TRUE(content::ExecuteScript(tab, "browsertestRunAllTests();"));
 
   content::TitleWatcher title_watcher(tab, ASCIIToUTF16("success"));
   title_watcher.AlsoWaitForTitle(ASCIIToUTF16("failure"));
   string16 result = title_watcher.WaitAndGetTitle();
   EXPECT_EQ(ASCIIToUTF16("success"), result);
 }
 
 }  // namespace extensions