Move MediaDeviceIDSalt from ProfileIOData to ProfileImpl.

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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/run_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 "build/build_config.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/webrtc_log_uploader.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/features.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"
@@ skipping 113 matching lines @@
     } else {
       (audio_manager->*EnumerationFunc)(device_descriptions);
       enumeration_event_.Signal();
     }
   }
 
   // Synchronously (from the calling thread's point of view) retrieve the
   // device id in the |origin| on the IO thread. On return,
   // |id_in_origin| contains the id |raw_device_id| is known by in
   // the origin.
-  void GetIDInOrigin(content::ResourceContext* resource_context,
+  void GetIDInOrigin(Profile* profile,
                      GURL origin,
                      const std::string& raw_device_id,
                      std::string* id_in_origin) {
     if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
           base::Bind(&WebrtcAudioPrivateTest::GetIDInOrigin,
-                     base::Unretained(this),
-                     resource_context, origin, raw_device_id, id_in_origin));
+                     base::Unretained(this), profile, origin, raw_device_id,
+                     id_in_origin));
       enumeration_event_.Wait();
     } else {
       *id_in_origin = content::GetHMACForMediaDeviceID(
-          resource_context->GetMediaDeviceIDSalt(), url::Origin(origin),
-          raw_device_id);
+          profile->GetMediaDeviceIDSalt(), url::Origin(origin), raw_device_id);
       enumeration_event_.Signal();
     }
   }
 
   // Event used to signal completion of enumeration.
   base::WaitableEvent enumeration_event_;
 
   GURL source_url_;
 };
 
@@ skipping 21 matching lines @@
        ++ix, ++it) {
     base::DictionaryValue* dict = NULL;
     sink_list->GetDictionary(ix, &dict);
     std::string sink_id;
     dict->GetString("sinkId", &sink_id);
 
     std::string expected_id;
     if (media::AudioDeviceDescription::IsDefaultDevice(it->unique_id)) {
       expected_id = media::AudioDeviceDescription::kDefaultDeviceId;
     } else {
-      GetIDInOrigin(profile()->GetResourceContext(),
-                    source_url_.GetOrigin(),
-                    it->unique_id,
+      GetIDInOrigin(profile(), source_url_.GetOrigin(), it->unique_id,
                     &expected_id);
     }
 
     EXPECT_EQ(expected_id, sink_id);
     std::string sink_label;
     dict->GetString("sinkLabel", &sink_label);
     EXPECT_EQ(it->device_name, sink_label);
 
     // TODO(joi): Verify the contents of these once we start actually
     // filling them in.
@@ skipping 115 matching lines @@
   // Try to get an associated sink for each source.
   for (const auto& device : devices) {
     scoped_refptr<WebrtcAudioPrivateGetAssociatedSinkFunction> function =
         new WebrtcAudioPrivateGetAssociatedSinkFunction();
     function->set_source_url(source_url_);
 
     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());
-    GetIDInOrigin(profile()->GetResourceContext(),
-                  origin,
-                  raw_device_id,
-                  &source_id_in_origin);
+    GetIDInOrigin(profile(), origin, raw_device_id, &source_id_in_origin);
 
     base::ListValue parameters;
     parameters.AppendString(origin.spec());
     parameters.AppendString(source_id_in_origin);
     std::string parameter_string;
     JSONWriter::Write(parameters, &parameter_string);
 
     std::unique_ptr<base::Value> result(RunFunctionAndReturnSingleResult(
         function.get(), parameter_string, browser()));
     std::string result_string;
@@ skipping 62 matching lines @@
   title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("failure"));
   base::string16 result = title_watcher.WaitAndGetTitle();
   EXPECT_EQ(base::ASCIIToUTF16("success"), result);
 
   g_browser_process->webrtc_log_uploader()->OverrideUploadWithBufferForTesting(
       NULL);
 }
 #endif  // BUILDFLAG(ENABLE_HANGOUT_SERVICES_EXTENSION)
 
 }  // namespace extensions