Add "interactive" UI integration tests for PermissionRequestManager.

chrome/browser/permissions/permission_request_manager_browsertest.cc

 // Copyright 2015 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/permissions/permission_request_manager.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "build/build_config.h"
+#include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
+#include "chrome/browser/custom_handlers/register_protocol_handler_permission_request.h"
+#include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
+#include "chrome/browser/media/webrtc/media_stream_devices_controller.h"
 #include "chrome/browser/permissions/permission_context_base.h"
+#include "chrome/browser/permissions/permission_request_impl.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/test/test_browser_dialog.h"
 #include "chrome/browser/ui/website_settings/mock_permission_prompt_factory.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
+using content::PermissionType;
+
 namespace {
 
 const char* kPermissionsKillSwitchFieldStudy =
     PermissionContextBase::kPermissionsKillSwitchFieldStudy;
 const char* kPermissionsKillSwitchBlockedValue =
     PermissionContextBase::kPermissionsKillSwitchBlockedValue;
 const char kPermissionsKillSwitchTestGroup[] = "TestGroup";
 
 class PermissionRequestManagerBrowserTest : public InProcessBrowserTest {
  public:
@@ skipping 15 matching lines @@
 
   PermissionRequestManager* GetPermissionRequestManager() {
     return PermissionRequestManager::FromWebContents(
         browser()->tab_strip_model()->GetActiveWebContents());
   }
 
   MockPermissionPromptFactory* bubble_factory() {
     return mock_permission_prompt_factory_.get();
   }
 
-  void EnableKillSwitch(content::PermissionType permission_type) {
+  void EnableKillSwitch(PermissionType permission_type) {
     std::map<std::string, std::string> params;
     params[PermissionUtil::GetPermissionString(permission_type)] =
         kPermissionsKillSwitchBlockedValue;
     variations::AssociateVariationParams(
         kPermissionsKillSwitchFieldStudy, kPermissionsKillSwitchTestGroup,
         params);
     base::FieldTrialList::CreateFieldTrial(kPermissionsKillSwitchFieldStudy,
                                            kPermissionsKillSwitchTestGroup);
   }
 
  private:
   std::unique_ptr<MockPermissionPromptFactory> mock_permission_prompt_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(PermissionRequestManagerBrowserTest);
 };
 
+// Harness for testing permissions dialogs invoked by PermissionRequestManager.
+// Uses a "real" PermissionPromptFactory rather than a mock.
+class PermissionDialogTest
+    : public SupportsTestDialog<PermissionRequestManagerBrowserTest> {
+ public:
+  // Values for dialog styles that are not a content::PermissionType.
+  enum CustomPermissionTypes {
+    REGISTER_PROTOCOL_HANDLER = 0,
+    MULTIPLE_REQUESTS = static_cast<int>(PermissionType::NUM),
+
+    // TODO(tapted): Implement these:
+    DOWNLOAD_MULTIPLE_FILES,
+    QUOTA_REQUEST,
+  };
+
+  PermissionDialogTest() {}
+
+  // InProcessBrowserTest:
+  void SetUpOnMainThread() override {
+    InProcessBrowserTest::SetUpOnMainThread();  // Skip super.
+  }
+
+  static std::vector<std::string> NameProvider() {
+    // Put RegisterProtocolHandler at index 0. There is no PermissionType with
+    // value 0, and no PermissionType for RPH, even though there is a request
+    // class for it. ShowDialog is called with index 0 when no dialog is chosen.
+    std::vector<std::string> names = {"RegisterProtocolHandler"};
+    auto add = [&names](PermissionType type, const std::string& name) {
+      EXPECT_EQ(names.size(), static_cast<size_t>(type));
+      names.push_back(name);
+    };
+    add(PermissionType::MIDI_SYSEX, "MidiSysex");
+
+    // Note: The next 2 look kinda the same.
+    add(PermissionType::PUSH_MESSAGING, "PushMessaging");
+    add(PermissionType::NOTIFICATIONS, "Notifications");
+
+    add(PermissionType::GEOLOCATION, "Geolocation");
+
+#if defined(OS_CHROMEOS)
+    // ProtectedMedia is ChromeOS only (fails with no icon otherwise).
+    add(PermissionType::PROTECTED_MEDIA_IDENTIFIER, "ProtectedMedia");
+#else
+    add(PermissionType::PROTECTED_MEDIA_IDENTIFIER, "DISABLED_ProtectedMedia");
+#endif
+
+    // Note: This fails because there is no icon.
+    add(PermissionType::MIDI, "DISABLED_Midi");
+
+    // Note: Doesn't prompt. See durable_storage_permission_context.cc.
+    add(PermissionType::DURABLE_STORAGE, "DISABLED_DurableStorage");
+
+    add(PermissionType::AUDIO_CAPTURE, "AudioCapture");
+    add(PermissionType::VIDEO_CAPTURE, "VideoCapture");
+
+    // Note: Doesn't prompt. See background_sync_manager.cc.
+    add(PermissionType::BACKGROUND_SYNC, "DISABLED_BackgroundSync");
+
+    add(PermissionType::FLASH, "Flash");
+    static_assert(static_cast<int>(PermissionType::NUM) == 12,
+                  "PermissionType count changed. Please update dialog tests.");
+
+    EXPECT_EQ(names.size(), MULTIPLE_REQUESTS);
+    names.push_back("MultipleRequests");
+    return names;
+  }
+
+  GURL GetUrl() { return GURL("https://example.com"); }
+
+  PermissionRequest* MakeRegisterProtocolHandlerRequest() {
+    std::string protocol = "mailto";
+    bool user_gesture = true;
+    ProtocolHandler handler =
+        ProtocolHandler::CreateProtocolHandler(protocol, GetUrl());
+    ProtocolHandlerRegistry* registry =
+        ProtocolHandlerRegistryFactory::GetForBrowserContext(
+            browser()->profile());
+    // Deleted in RegisterProtocolHandlerPermissionRequest::RequestFinished().
+    return new RegisterProtocolHandlerPermissionRequest(registry, handler,
+                                                        GetUrl(), user_gesture);
+  }
+
+  PermissionRequest* MakeMediaRequest(PermissionType permission) {
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    content::MediaStreamRequestType request_type = content::MEDIA_DEVICE_ACCESS;
+    content::MediaStreamType audio_type = content::MEDIA_NO_SERVICE;
+    content::MediaStreamType video_type = content::MEDIA_NO_SERVICE;
+    std::string audio_id = "audio_id";
+    std::string video_id = "video_id";
+
+    if (permission == PermissionType::AUDIO_CAPTURE)
+      audio_type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+    else
+      video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
+    content::MediaStreamRequest request(0, 0, 0, GetUrl(), false, request_type,
+                                        audio_id, video_id, audio_type,
+                                        video_type, false);
+
+    // Add fake devices, otherwise the request will auto-block.
+    MediaCaptureDevicesDispatcher::GetInstance()->SetTestAudioCaptureDevices(
+        content::MediaStreamDevices(
+            1, content::MediaStreamDevice(content::MEDIA_DEVICE_AUDIO_CAPTURE,
+                                          audio_id, "Fake Audio")));
+    MediaCaptureDevicesDispatcher::GetInstance()->SetTestVideoCaptureDevices(
+        content::MediaStreamDevices(
+            1, content::MediaStreamDevice(content::MEDIA_DEVICE_VIDEO_CAPTURE,
+                                          video_id, "Fake Video")));
+
+    auto response = [](const content::MediaStreamDevices& devices,
+                       content::MediaStreamRequestResult result,
+                       std::unique_ptr<content::MediaStreamUI> ui) {};
+    // Deleted in MediaStreamDevicesController::RequestFinished().
+    return new MediaStreamDevicesController(web_contents, request,
+                                            base::Bind(response));
+  }
+
+  PermissionRequest* MakeRequest(PermissionType permission) {
+    if (permission == PermissionType::AUDIO_CAPTURE ||
+        permission == PermissionType::VIDEO_CAPTURE)
+      return MakeMediaRequest(permission);
+
+    bool user_gesture = true;
+    auto decided = [](bool, ContentSetting) {};
+    auto cleanup = [] {};  // Leave cleanup to test harness destructor.
+    owned_requests_.push_back(base::MakeUnique<PermissionRequestImpl>(
+        GetUrl(), permission, browser()->profile(), user_gesture,
+        base::Bind(decided), base::Bind(cleanup)));
+    return owned_requests_.back().get();
+  }
+
+  // TestDialogInterface:
+  void ShowDialog(int index) override {
+    PermissionRequestManager* manager = GetPermissionRequestManager();
+    if (index == REGISTER_PROTOCOL_HANDLER) {
+      manager->AddRequest(MakeRegisterProtocolHandlerRequest());
+    } else if (index < static_cast<int>(PermissionType::NUM)) {
+      PermissionType permission = static_cast<PermissionType>(index);
+      manager->AddRequest(MakeRequest(permission));
+    } else if (index == MULTIPLE_REQUESTS) {
+      // Only types handled in PermissionRequestImpl::GetMessageTextFragment()
+      // can be combined this way.
+      manager->AddRequest(MakeRequest(PermissionType::GEOLOCATION));
+      manager->AddRequest(MakeRequest(PermissionType::NOTIFICATIONS));
+      manager->AddRequest(MakeRequest(PermissionType::MIDI_SYSEX));
+    } else {
+      NOTREACHED();
+    }
+    manager->DisplayPendingRequests();
+  }
+
+ private:
+  std::vector<std::unique_ptr<PermissionRequest>> owned_requests_;
+
+  DISALLOW_COPY_AND_ASSIGN(PermissionDialogTest);
+};
+
+TEST_BROWSER_DIALOG(PermissionDialogTest);
+
 // Requests before the load event should be bundled into one bubble.
 // http://crbug.com/512849 flaky
 IN_PROC_BROWSER_TEST_F(PermissionRequestManagerBrowserTest,
                        DISABLED_RequestsBeforeLoad) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(),
       embedded_test_server()->GetURL("/permissions/requests-before-load.html"),
       1);
@@ skipping 102 matching lines @@
 // Bubble requests should not be shown when the killswitch is on.
 IN_PROC_BROWSER_TEST_F(PermissionRequestManagerBrowserTest,
                        KillSwitchGeolocation) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL("/permissions/killswitch_tester.html"));
 
   // Now enable the geolocation killswitch.
-  EnableKillSwitch(content::PermissionType::GEOLOCATION);
+  EnableKillSwitch(PermissionType::GEOLOCATION);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       web_contents, "requestGeolocation();", &result));
   EXPECT_EQ("denied", result);
   EXPECT_EQ(0, bubble_factory()->show_count());
   EXPECT_EQ(0, bubble_factory()->total_request_count());
 
@@ skipping 15 matching lines @@
 // Bubble requests should not be shown when the killswitch is on.
 IN_PROC_BROWSER_TEST_F(PermissionRequestManagerBrowserTest,
                        KillSwitchNotifications) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL("/permissions/killswitch_tester.html"));
 
   // Now enable the notifications killswitch.
-  EnableKillSwitch(content::PermissionType::NOTIFICATIONS);
+  EnableKillSwitch(PermissionType::NOTIFICATIONS);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       web_contents, "requestNotification();", &result));
   EXPECT_EQ("denied", result);
   EXPECT_EQ(0, bubble_factory()->show_count());
   EXPECT_EQ(0, bubble_factory()->total_request_count());
 
   // Disable the trial.
   variations::testing::ClearAllVariationParams();
 
   EXPECT_TRUE(content::ExecuteScript(web_contents, "requestNotification();"));
   bubble_factory()->WaitForPermissionBubble();
   EXPECT_EQ(1, bubble_factory()->show_count());
   EXPECT_EQ(1, bubble_factory()->total_request_count());
 }
 
 }  // anonymous namespace