Per navigation sticky media permissions.

chrome/browser/media/chrome_media_stream_infobar_browsertest.cc

Index: chrome/browser/media/chrome_media_stream_infobar_browsertest.cc
diff --git a/chrome/browser/media/chrome_media_stream_infobar_browsertest.cc b/chrome/browser/media/chrome_media_stream_infobar_browsertest.cc
index e0833408c04cb4024a54dfa6ffb6a397417c4c60..49cc42c788734006a66a98238596decf639d7426 100644
--- a/chrome/browser/media/chrome_media_stream_infobar_browsertest.cc
+++ b/chrome/browser/media/chrome_media_stream_infobar_browsertest.cc
@@ -9,6 +9,7 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/browser/media/media_stream_devices_controller.h"
 #include "chrome/browser/media/webrtc_browsertest_base.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
 #include "chrome/browser/profiles/profile.h"
@@ -22,6 +23,7 @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/common/media_stream_request.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 
@@ -50,21 +52,56 @@ class MediaStreamInfoBarTest : public WebRtcTestBase {
     return LoadTestPageInBrowser(CreateIncognitoBrowser());
   }
 
+  // Returns the URL of the main test page.
+  GURL test_page_url() const {
+    const char kMainWebrtcTestHtmlPage[] =
+        "files/webrtc/webrtc_jsep01_test.html";
+    return test_server()->GetURL(kMainWebrtcTestHtmlPage);
+  }
+
+  // Denies getUserMedia requests (audio, video) for the test page.
+  // The deny setting is sticky.
+  void DenyRequest(content::WebContents* tab_contents,
+                   content::MediaStreamRequestResult result) const {
+    const std::string no_id;
+    content::MediaStreamRequest request(
+        0, 0, 0, test_page_url().GetOrigin(), false,
+        content::MEDIA_DEVICE_ACCESS, no_id, no_id,
+        content::MEDIA_DEVICE_AUDIO_CAPTURE,
+        content::MEDIA_DEVICE_VIDEO_CAPTURE);
+
+    scoped_ptr<MediaStreamDevicesController> controller(
+        new MediaStreamDevicesController(tab_contents, request,
+            base::Bind(&OnMediaStreamResponse)));
+    controller->Deny(true, result);
+  }
+
+  // Executes stopLocalStream() in the test page, which frees up an already
+  // acquired mediastream.
+  bool StopLocalStream(content::WebContents* tab_contents) {
+    std::string result;
+    bool ok = content::ExecuteScriptAndExtractString(
+        tab_contents, "stopLocalStream()", &result);

[perkj_chrome, 2014/05/05 07:28:25]

Do you know what this uses? Stop the tracks or stop the mediastream?  Since
MediaStream::Stop is deprecated, we should at least not add new dependencies on
it.

[tommi (sloooow) - chröme, 2014/05/05 08:02:54]

I think it does the right thing but you can verify:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/test/data/w...

+    DCHECK(ok);
+    return result.compare("ok-stopped") == 0;
+  }
+
  private:
   content::WebContents* LoadTestPageInBrowser(Browser* browser) {
     EXPECT_TRUE(test_server()->Start());
 
-    const char kMainWebrtcTestHtmlPage[] =
-        "files/webrtc/webrtc_jsep01_test.html";
-    ui_test_utils::NavigateToURL(
-        browser, test_server()->GetURL(kMainWebrtcTestHtmlPage));
+    ui_test_utils::NavigateToURL(browser, test_page_url());
     return browser->tab_strip_model()->GetActiveWebContents();
   }
 
+  // Dummy callback for when we deny the current request directly.
+  static void OnMediaStreamResponse(const content::MediaStreamDevices& devices,
+                                    content::MediaStreamRequestResult result,
+                                    scoped_ptr<content::MediaStreamUI> ui) {}
+
   DISALLOW_COPY_AND_ASSIGN(MediaStreamInfoBarTest);
 };
 
-
 // Actual tests ---------------------------------------------------------------
 
 // Failing on ChromiumOS Debug and Win Aura, so disabling on both.
@@ -114,7 +151,7 @@ IN_PROC_BROWSER_TEST_F(MediaStreamInfoBarTest,
   content::WebContents* tab_contents = LoadTestPageInTab();
 
   GetUserMediaAndAccept(tab_contents);
-  GetUserMediaAndDeny(tab_contents);
+  DenyRequest(tab_contents, content::MEDIA_DEVICE_PERMISSION_DENIED);
 
   // Should fail with permission denied right away with no infobar popping up.
   GetUserMedia(tab_contents, kAudioVideoCallConstraints);
@@ -139,9 +176,58 @@ IN_PROC_BROWSER_TEST_F(MediaStreamInfoBarTest, MAYBE_TestAcceptIsNotSticky) {
   // If accept were sticky the second call would hang because it hangs if an
   // infobar does not pop up.
   GetUserMediaAndAccept(tab_contents);
+
+  // Because http request permissions are sticky per navigation, we need to
+  // navigate away from the current page in order to verify that the granted
+  // permissions are not permanently sticky.
+  ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(),
+      GURL("about:blank"), 1);
+
+  // Now navigate back to our test page.
+  ui_test_utils::NavigateToURL(browser(), test_page_url());
+  tab_contents = browser()->tab_strip_model()->GetActiveWebContents();
+
   GetUserMediaAndAccept(tab_contents);
 }
 
+// Test that accepting one getUserMedia request will not require a second
+// prompt when issuing a second getUserMedia request.
+IN_PROC_BROWSER_TEST_F(MediaStreamInfoBarTest,
+                       TestAcceptIsStickyPerNavigation) {
+  content::WebContents* tab_contents = LoadTestPageInTab();
+
+  GetUserMediaAndAccept(tab_contents);
+
+  // Before issuing the second gUM request, make sure we first stop the tracks
+  // we started with the first request. If they're still running the permissions
+  // will be active for other reasons and we won't be testing the temporary
+  // stickiness properly.
+  EXPECT_TRUE(StopLocalStream(tab_contents));
+
+  // Now no media tracks are running, so let's issue the second request.
+  GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+}
+
+IN_PROC_BROWSER_TEST_F(MediaStreamInfoBarTest,
+                       TestTwoAcceptsPlusStickyPerNavigation) {
+  content::WebContents* tab_contents = LoadTestPageInTab();
+
+  // First ask for audio only and approve.
+  GetUserMediaWithSpecificConstraintsAndAccept(tab_contents,
+                                               kAudioOnlyCallConstraints);
+  EXPECT_TRUE(StopLocalStream(tab_contents));
+
+  // Next ask for video permissions.
+  // This will hang if the previous gUM call somehow gave video permissions.
+  GetUserMediaWithSpecificConstraintsAndAccept(tab_contents,
+                                               kVideoOnlyCallConstraints);
+  EXPECT_TRUE(StopLocalStream(tab_contents));
+
+  // Now ask for both audio and video and expect the call to go through without
+  // showing any UI.
+  GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+}
+
 IN_PROC_BROWSER_TEST_F(MediaStreamInfoBarTest, TestDismissIsNotSticky) {
   content::WebContents* tab_contents = LoadTestPageInTab();