Fix webrtcAudioPrivate API to handle requests from <webview>s.

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/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"
@@ skipping 14 matching lines @@
 #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 "media/audio/audio_manager_base.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONWriter;
-using content::RenderViewHost;
+using content::RenderProcessHost;
 using content::WebContents;
 using media::AudioDeviceNames;
 using media::AudioManager;
 
 namespace extensions {
 
 using extension_function_test_utils::RunFunctionAndReturnError;
 using extension_function_test_utils::RunFunctionAndReturnSingleResult;
 
 class AudioWaitingExtensionTest : public ExtensionApiTest {
  protected:
   void WaitUntilAudioIsPlaying(WebContents* tab) {
     // Wait for audio to start playing. We gate this on there being one
     // or more AudioOutputController objects for our tab.
     bool audio_playing = false;
     for (size_t remaining_tries = 50; remaining_tries > 0; --remaining_tries) {
-      tab->GetRenderViewHost()->GetAudioOutputControllers(
+      tab->GetRenderProcessHost()->GetAudioOutputControllers(
           base::Bind(OnAudioControllers, &audio_playing));
       base::MessageLoop::current()->RunUntilIdle();
       if (audio_playing)
         break;
 
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
     }
 
     if (!audio_playing)
       FAIL() << "Audio did not start playing within ~5 seconds.";
   }
 
   // Used by the test above to wait until audio is playing.
   static void OnAudioControllers(
       bool* audio_playing,
-      const RenderViewHost::AudioOutputControllerList& list) {
+      const RenderProcessHost::AudioOutputControllerList& list) {
     if (!list.empty())
       *audio_playing = true;
   }
 };
 
 class WebrtcAudioPrivateTest : public AudioWaitingExtensionTest {
  public:
   WebrtcAudioPrivateTest()
       : enumeration_event_(false, false) {
   }
 
   void SetUpOnMainThread() override {
     AudioWaitingExtensionTest::SetUpOnMainThread();
     // Needs to happen after chrome's schemes are added.
     source_url_ = GURL("chrome-extension://fakeid012345678/fakepage.html");
   }
 
  protected:
+  void AppendTabIdToRequestInfo(base::ListValue* params, int tab_id) {
+    base::DictionaryValue* request_info = new base::DictionaryValue();
+    request_info->SetInteger("tabId", tab_id);
+    params->Append(request_info);
+  }
+
   std::string InvokeGetActiveSink(int tab_id) {
     base::ListValue parameters;
-    parameters.AppendInteger(tab_id);
+    AppendTabIdToRequestInfo(&parameters, tab_id);
     std::string parameter_string;
     JSONWriter::Write(&parameters, &parameter_string);
 
     scoped_refptr<WebrtcAudioPrivateGetActiveSinkFunction> function =
         new WebrtcAudioPrivateGetActiveSinkFunction();
     function->set_source_url(source_url_);
     scoped_ptr<base::Value> result(
         RunFunctionAndReturnSingleResult(function.get(),
                                          parameter_string,
                                          browser()));
@@ skipping 114 matching lines @@
   }
 }
 #endif  // OS_MACOSX
 
 // This exercises the case where you have a tab with no active media
 // stream and try to retrieve the currently active audio sink.
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetActiveSinkNoMediaStream) {
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   int tab_id = ExtensionTabUtil::GetTabId(tab);
   base::ListValue parameters;
-  parameters.AppendInteger(tab_id);
+  AppendTabIdToRequestInfo(&parameters, tab_id);
   std::string parameter_string;
   JSONWriter::Write(&parameters, &parameter_string);
 
   scoped_refptr<WebrtcAudioPrivateGetActiveSinkFunction> function =
       new WebrtcAudioPrivateGetActiveSinkFunction();
   function->set_source_url(source_url_);
   scoped_ptr<base::Value> result(
       RunFunctionAndReturnSingleResult(function.get(),
                                        parameter_string,
                                        browser()));
 
   std::string result_string;
   JSONWriter::Write(result.get(), &result_string);
   EXPECT_EQ("\"\"", result_string);
 }
 
 // This exercises the case where you have a tab with no active media
 // stream and try to set the audio sink.
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, SetActiveSinkNoMediaStream) {
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   int tab_id = ExtensionTabUtil::GetTabId(tab);
   base::ListValue parameters;
-  parameters.AppendInteger(tab_id);
+  AppendTabIdToRequestInfo(&parameters, tab_id);
   parameters.AppendString("no such id");
   std::string parameter_string;
   JSONWriter::Write(&parameters, &parameter_string);
 
   scoped_refptr<WebrtcAudioPrivateSetActiveSinkFunction> function =
       new WebrtcAudioPrivateSetActiveSinkFunction();
   function->set_source_url(source_url_);
   std::string error(RunFunctionAndReturnError(function.get(),
                                               parameter_string,
                                               browser()));
-  EXPECT_EQ(base::StringPrintf("No active stream for tab with id: %d.", tab_id),
+  EXPECT_EQ(base::StringPrintf("No active stream for tabId %d", tab_id),
             error);
 }
 
 IN_PROC_BROWSER_TEST_F(WebrtcAudioPrivateTest, GetAndSetWithMediaStream) {
   // First retrieve the list of all sinks, so that we can run a test
   // where we set the active sink to each of the different available
   // sinks in turn.
   base::ListValue* sink_list = NULL;
   scoped_ptr<base::Value> result = InvokeGetSinks(&sink_list);
 
@@ skipping 14 matching lines @@
   EXPECT_NE("", current_device);
 
   // Set to each of the other devices in turn.
   for (size_t ix = 0; ix < sink_list->GetSize(); ++ix) {
     base::DictionaryValue* dict = NULL;
     sink_list->GetDictionary(ix, &dict);
     std::string target_device;
     dict->GetString("sinkId", &target_device);
 
     base::ListValue parameters;
-    parameters.AppendInteger(tab_id);
+    AppendTabIdToRequestInfo(&parameters, tab_id);
     parameters.AppendString(target_device);
     std::string parameter_string;
     JSONWriter::Write(&parameters, &parameter_string);
 
     scoped_refptr<WebrtcAudioPrivateSetActiveSinkFunction> function =
       new WebrtcAudioPrivateSetActiveSinkFunction();
     function->set_source_url(source_url_);
     scoped_ptr<base::Value> result(RunFunctionAndReturnSingleResult(
         function.get(), parameter_string, browser()));
     // The function was successful if the above invocation doesn't
@@ skipping 106 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  // defined(GOOGLE_CHROME_BUILD) || defined(ENABLE_HANGOUT_SERVICES_EXTENSION)
 
 }  // namespace extensions