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

content/browser/renderer_host/media/media_stream_dispatcher_host_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 <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.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/media_device_id.h"
 #include "content/public/test/mock_resource_context.h"
+#include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 const int kProcessId = 5;
 const int kRenderId = 6;
 const int kPageRequestId = 7;
 
 namespace content {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
+      ResourceContext* resource_context,
       const scoped_refptr<base::MessageLoopProxy>& message_loop,
       MediaStreamManager* manager)
-      : MediaStreamDispatcherHost(kProcessId, manager),
+      : MediaStreamDispatcherHost(kProcessId, resource_context, manager),
         message_loop_(message_loop) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
   MOCK_METHOD2(OnStreamGenerationFailed, void(int routing_id, int request_id));
   MOCK_METHOD1(OnDeviceStopped, void(int routing_id));
   MOCK_METHOD2(OnDeviceOpened, void(int routing_id, int request_id));
 
@@ skipping 147 matching lines @@
       : old_browser_client_(NULL),
         thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         origin_("https://test.com") {
     audio_manager_.reset(
         new media::MockAudioManager(base::MessageLoopProxy::current()));
     // Create our own MediaStreamManager.
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     // Make sure we use fake devices to avoid long delays.
     media_stream_manager_->UseFakeDevice();
 
-    host_ = new MockMediaStreamDispatcherHost(base::MessageLoopProxy::current(),
-                                              media_stream_manager_.get());
+    host_ = new MockMediaStreamDispatcherHost(
+        browser_context_.GetResourceContext(),
+        base::MessageLoopProxy::current(),
+        media_stream_manager_.get());
 
     // Use the fake content client and browser.
     content_client_.reset(new TestContentClient());
     SetContentClient(content_client_.get());
     old_browser_client_ = SetBrowserClientForTesting(host_.get());
   }
 
   virtual ~MediaStreamDispatcherHostTest() {
   }
 
@@ skipping 94 matching lines @@
     return false;
   }
 
   bool DoesEveryDeviceMapToRawId(const StreamDeviceInfoArray& devices,
                                  const GURL& origin) {
     for (size_t i = 0; i < devices.size(); ++i) {
       bool found_match = false;
       media::AudioDeviceNames::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
-        if (content::DoesMediaDeviceIDMatchHMAC(origin,
-                                                devices[i].device.id,
-                                                audio_it->unique_id)) {
+        if (content::DoesMediaDeviceIDMatchHMAC(
+            browser_context_.GetResourceContext(),
+            origin,
+            devices[i].device.id,
+            audio_it->unique_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       media::VideoCaptureDevice::Names::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
-        if (content::DoesMediaDeviceIDMatchHMAC(origin,
-                                                devices[i].device.id,
-                                                video_it->id())) {
+        if (content::DoesMediaDeviceIDMatchHMAC(
+            browser_context_.GetResourceContext(),
+            origin,
+            devices[i].device.id,
+            video_it->id())) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       if (!found_match)
         return false;
     }
     return true;
   }
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   ContentBrowserClient* old_browser_client_;
   scoped_ptr<ContentClient> content_client_;
   content::TestBrowserThreadBundle thread_bundle_;
+  content::TestBrowserContext browser_context_;
   media::AudioDeviceNames physical_audio_devices_;
   media::VideoCaptureDevice::Names physical_video_devices_;
   GURL origin_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
@@ skipping 132 matching lines @@
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithSourceId) {
   ASSERT_GE(physical_audio_devices_.size(), 1u);
   ASSERT_GE(physical_video_devices_.size(), 1u);
 
   media::AudioDeviceNames::const_iterator audio_it =
       physical_audio_devices_.begin();
   for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
     StreamOptions options(MEDIA_DEVICE_AUDIO_CAPTURE,
                           MEDIA_DEVICE_VIDEO_CAPTURE);
     options.audio_device_id = content::GetHMACForMediaDeviceID(
+        browser_context_.GetResourceContext(),
         origin_,
         audio_it->unique_id);
     ASSERT_FALSE(options.audio_device_id.empty());
 
     // Generate first stream.
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
     EXPECT_EQ(host_->audio_devices_[0].device.id, options.audio_device_id);
   }
 
   media::VideoCaptureDevice::Names::const_iterator video_it =
       physical_video_devices_.begin();
   for (; video_it != physical_video_devices_.end(); ++video_it) {
     StreamOptions options(MEDIA_DEVICE_AUDIO_CAPTURE,
                           MEDIA_DEVICE_VIDEO_CAPTURE);
-    options.video_device_id = content::GetHMACForMediaDeviceID(origin_,
-                                                               video_it->id());
+    options.video_device_id = content::GetHMACForMediaDeviceID(
+        browser_context_.GetResourceContext(),
+        origin_,
+        video_it->id());
     ASSERT_FALSE(options.video_device_id.empty());
 
     // Generate first stream.
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
     EXPECT_EQ(host_->video_devices_[0].device.id, options.video_device_id);
   }
 }
 
 // Test that generating a stream with an invalid video source id fail.
@@ skipping 170 matching lines @@
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_AUDIO_CAPTURE);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
 }
 
 };  // namespace content