Switch media stream permissions to use IsOriginSecure() instead of SchemeIsSecure().

chrome/browser/media/webrtc_browsertest_base.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 "chrome/browser/media/webrtc_browsertest_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
@@ skipping 60 matching lines @@
 
   bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos;
   if (severity == logging::LOG_ERROR ||
       (severity == logging::LOG_INFO && contains_uncaught)) {
     hit_javascript_errors_.Get() = true;
   }
 
   return false;
 }
 
+// PermissionRequestObserver ---------------------------------------------------
+
+// Used to observe the creation of permission prompt without responding.
+class PermissionRequestObserver : public PermissionBubbleManager::Observer {
+ public:
+  explicit PermissionRequestObserver(content::WebContents* web_contents)
+      : bubble_manager_(PermissionBubbleManager::FromWebContents(web_contents)),
+        request_shown_(false),
+        message_loop_runner_(new content::MessageLoopRunner) {
+    bubble_manager_->AddObserver(this);
+  }
+  ~PermissionRequestObserver() override {
+    // Safe to remove twice if it happens.
+    bubble_manager_->RemoveObserver(this);
+  }
+
+  void Wait() { message_loop_runner_->Run(); }
+
+  bool request_shown() { return request_shown_; }
+
+ private:
+  // PermissionBubbleManager::Observer
+  void OnBubbleAdded() override {
+    request_shown_ = true;
+    bubble_manager_->RemoveObserver(this);
+    message_loop_runner_->Quit();
+  }
+
+  PermissionBubbleManager* bubble_manager_;
+  bool request_shown_;
+  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(PermissionRequestObserver);
+};
+
 }  // namespace
 
 WebRtcTestBase::WebRtcTestBase(): detect_errors_in_javascript_(false) {
   // The handler gets set for each test method, but that's fine since this
   // set operation is idempotent.
   logging::SetLogMessageHandler(&JavascriptErrorDetectingLogHandler);
   hit_javascript_errors_.Get() = false;
 
   EnablePixelOutput();
 }
@@ skipping 11 matching lines @@
   return GetUserMediaWithSpecificConstraintsAndAccept(
       tab_contents, kAudioVideoCallConstraints);
 }
 
 bool WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
   std::string result;
   PermissionBubbleManager::FromWebContents(tab_contents)
       ->set_auto_response_for_test(PermissionBubbleManager::ACCEPT_ALL);
+  PermissionRequestObserver permissionRequestObserver(tab_contents);
   GetUserMedia(tab_contents, constraints);
+  EXPECT_TRUE(permissionRequestObserver.request_shown());
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
   return kOkGotStream == result;
 }
 
 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
                                                     kAudioVideoCallConstraints);
 }
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
   std::string result;
   PermissionBubbleManager::FromWebContents(tab_contents)
       ->set_auto_response_for_test(PermissionBubbleManager::DENY_ALL);
+  PermissionRequestObserver permissionRequestObserver(tab_contents);
   GetUserMedia(tab_contents, constraints);
+  EXPECT_TRUE(permissionRequestObserver.request_shown());
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
   EXPECT_EQ(kFailedWithPermissionDeniedError, result);
 }
 
 void WebRtcTestBase::GetUserMediaAndDismiss(
     content::WebContents* tab_contents) const {
   std::string result;
   PermissionBubbleManager::FromWebContents(tab_contents)
       ->set_auto_response_for_test(PermissionBubbleManager::DISMISS);
+  PermissionRequestObserver permissionRequestObserver(tab_contents);
   GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+  EXPECT_TRUE(permissionRequestObserver.request_shown());
   // A dismiss should be treated like a deny.
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
   EXPECT_EQ(kFailedWithPermissionDismissedError, result);
 }
 
+void WebRtcTestBase::GetUserMediaAndExpectAutoAcceptWithoutPrompt(

[felt, 2015/08/06 18:40:13]

This is kind of confusing, because you don't actually expect any prompt to
appear in the normal case yet are setting an autoresponder. Can you update the
comment to specify that the only reason for the PBM here is to document that it
does *not* appear?

[lgarron, 2015/08/06 22:10:09]

Done.

+    content::WebContents* tab_contents) const {
+  std::string result;
+  // Try to deny, to sanity check that auto-accept is overriding.
+  PermissionBubbleManager::FromWebContents(tab_contents)
+      ->set_auto_response_for_test(PermissionBubbleManager::DENY_ALL);
+  PermissionRequestObserver permissionRequestObserver(tab_contents);
+  GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+  EXPECT_FALSE(permissionRequestObserver.request_shown());
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+  EXPECT_EQ(kOkGotStream, result);
+}
+
+void WebRtcTestBase::GetUserMediaAndExpectAutoDenyWithoutPrompt(
+    content::WebContents* tab_contents) const {
+  std::string result;
+  // Try to accept, to sanity check that auto-deny is overriding.
+  PermissionBubbleManager::FromWebContents(tab_contents)
+      ->set_auto_response_for_test(PermissionBubbleManager::ACCEPT_ALL);
+  PermissionRequestObserver permissionRequestObserver(tab_contents);
+  GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+  EXPECT_FALSE(permissionRequestObserver.request_shown());
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+  EXPECT_EQ(kFailedWithPermissionDeniedError, result);
+}
+
 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
                                   const std::string& constraints) const {
   // Request user media: this will launch the media stream info bar or bubble.
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents, "doGetUserMedia(" + constraints + ");", &result));
   EXPECT_TRUE(result == "request-callback-denied" ||
               result == "request-callback-granted");
 }
 
 content::WebContents* WebRtcTestBase::OpenPageAndGetUserMediaInNewTab(
     const GURL& url) const {
   return OpenPageAndGetUserMediaInNewTabWithConstraints(
       url, kAudioVideoCallConstraints);
 }
 
 content::WebContents*
 WebRtcTestBase::OpenPageAndGetUserMediaInNewTabWithConstraints(
     const GURL& url,
     const std::string& constraints) const {
   chrome::AddTabAt(browser(), GURL(), -1, true);
   ui_test_utils::NavigateToURL(browser(), url);
   content::WebContents* new_tab =
       browser()->tab_strip_model()->GetActiveWebContents();
-  EXPECT_TRUE(GetUserMediaWithSpecificConstraintsAndAccept(
-      new_tab, constraints));
+  // Accept if necessary, but don't expect a prompt (because auto-accept is also
+  // okay).
+  PermissionBubbleManager::FromWebContents(new_tab)
+      ->set_auto_response_for_test(PermissionBubbleManager::ACCEPT_ALL);
+  GetUserMedia(new_tab, constraints);
+  std::string result;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      new_tab->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+  EXPECT_EQ(kOkGotStream, result);
   return new_tab;
 }
 
 content::WebContents* WebRtcTestBase::OpenTestPageAndGetUserMediaInNewTab(
     const std::string& test_page) const {
   return OpenPageAndGetUserMediaInNewTab(
       embedded_test_server()->GetURL(test_page));
 }
 
 void WebRtcTestBase::CloseLastLocalStream(
@@ skipping 128 matching lines @@
 #endif
 }
 
 bool WebRtcTestBase::OnWin8() const {
 #if defined(OS_WIN)
   return base::win::GetVersion() > base::win::VERSION_WIN7;
 #else
   return false;
 #endif
 }