Public Sessions - prompt the user for pageCapture requests

chrome/browser/chromeos/extensions/public_session_permission_helper_unittest.cc

+// Copyright 2017 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/chromeos/extensions/public_session_permission_helper.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
+#include "chrome/browser/extensions/extension_install_prompt.h"
+#include "chrome/common/extensions/extension_test_util.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
+#include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_dialog_auto_confirm.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/manifest.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using extension_test_util::LoadManifestUnchecked;
+using content::WebContents;
+using extensions::APIPermission;
+using extensions::Extension;
+using extensions::Manifest;
+using Result = ExtensionInstallPrompt::Result;
+
+namespace {
+
+auto permission_a = APIPermission::kAudio;
+auto permission_b = APIPermission::kBookmark;
+
+scoped_refptr<Extension> LoadManifestHelper(const std::string& id) {
+  std::string error;
+  scoped_refptr<Extension> extension = LoadManifestUnchecked(
+      "common/background_page", "manifest.json", Manifest::INVALID_LOCATION,
+      Extension::NO_FLAGS, id, &error);
+  EXPECT_TRUE(extension.get()) << error;
+  return extension;
+}
+
+class ProgrammableInstallPrompt : public ExtensionInstallPrompt {
+ public:
+  explicit ProgrammableInstallPrompt(WebContents* contents)
+      : ExtensionInstallPrompt(contents) {}
+
+  ~ProgrammableInstallPrompt() override {}
+
+  void ShowDialog(
+      const DoneCallback& done_callback,
+      const extensions::Extension* extension,
+      const SkBitmap* icon,
+      std::unique_ptr<Prompt> prompt,
+      std::unique_ptr<const extensions::PermissionSet> custom_permissions,
+      const ShowDialogCallback& show_dialog_callback) override {
+    done_callback_ = done_callback;
+  }
+
+  void Resolve(ExtensionInstallPrompt::Result result) {
+    done_callback_.Run(result);
+  }
+
+ private:
+  ExtensionInstallPrompt::DoneCallback done_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProgrammableInstallPrompt);
+};
+
+}  // namespace
+
+namespace extensions {
+namespace permission_helper {
+
+class PublicSessionPermissionHelperTest
+    : public ChromeRenderViewHostTestHarness {
+ public:
+  PublicSessionPermissionHelperTest() {}
+  ~PublicSessionPermissionHelperTest() override {}
+
+  // testing::Test
+  void SetUp() override;
+  void TearDown() override;
+
+  // Class helpers.
+  void RequestResolved(PermissionIDSet allowed_permissions);
+  ProgrammableInstallPrompt* CallHandlePermissionRequest(
+      const scoped_refptr<Extension>& extension,
+      PermissionIDSet permissions);
+
+ protected:
+  scoped_refptr<Extension> extension_a_;
+  scoped_refptr<Extension> extension_b_;
+
+  std::vector<PermissionIDSet> allowed_permissions_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PublicSessionPermissionHelperTest);
+};
+
+void PublicSessionPermissionHelperTest::SetUp() {
+  ChromeRenderViewHostTestHarness::SetUp();
+  extension_a_ = LoadManifestHelper("extension_a");
+  extension_b_ = LoadManifestHelper("extension_b");
+}
+
+void PublicSessionPermissionHelperTest::TearDown() {
+  ResetPermissionsForTesting();
+  ChromeRenderViewHostTestHarness::TearDown();
+}
+
+void PublicSessionPermissionHelperTest::RequestResolved(
+    PermissionIDSet allowed_permissions) {
+  allowed_permissions_.push_back(std::move(allowed_permissions));
+}
+
+ProgrammableInstallPrompt*
+PublicSessionPermissionHelperTest::CallHandlePermissionRequest(
+    const scoped_refptr<Extension>& extension,
+    PermissionIDSet permissions) {
+  ProgrammableInstallPrompt* prompt =
+      new ProgrammableInstallPrompt(web_contents());
+  SetExtensionInstallPromptForTesting(prompt);
+  HandlePermissionRequest(
+      *extension.get(), std::move(permissions), web_contents(),
+      base::Bind(&PublicSessionPermissionHelperTest::RequestResolved,
+                 base::Unretained(this)));
+  return prompt;
+}
+
+TEST_F(PublicSessionPermissionHelperTest, TestPermissionAllowed) {
+  // Allow permission_a for extension_a.
+  CallHandlePermissionRequest(extension_a_, {permission_a})
+      ->Resolve(Result::ACCEPTED);
+  EXPECT_TRUE(allowed_permissions_.back().Equals({permission_a}));
+
+  // permission_a was already allowed for extension_a.
+  CallHandlePermissionRequest(extension_a_, {permission_a});
+  EXPECT_TRUE(allowed_permissions_.back().Equals({permission_a}));
+
+  // permission_a was allowed only for extension_a.
+  CallHandlePermissionRequest(extension_b_, {permission_a})
+      ->Resolve(Result::USER_CANCELED);
+  EXPECT_TRUE(allowed_permissions_.back().Equals({}));
+}
+
+TEST_F(PublicSessionPermissionHelperTest, TestPermissionDenied) {
+  // Deny permission_a for extension_a.
+  CallHandlePermissionRequest(extension_a_, {permission_a})
+      ->Resolve(Result::USER_CANCELED);
+  EXPECT_TRUE(allowed_permissions_.back().Equals({}));
+
+  // Still denied (previous choice is remembered).
+  CallHandlePermissionRequest(extension_a_, {permission_a});
+  EXPECT_TRUE(allowed_permissions_.back().Equals({}));
+
+  // permission_a was denied only for extension_a.
+  CallHandlePermissionRequest(extension_b_, {permission_a})
+      ->Resolve(Result::ACCEPTED);
+  EXPECT_TRUE(allowed_permissions_.back().Equals({permission_a}));
+}
+
+TEST_F(PublicSessionPermissionHelperTest, TestTwoPromptsA) {
+  // Open two permission prompts.
+  auto prompt1 =
+      CallHandlePermissionRequest(extension_a_, {permission_a, permission_b});
+  CallHandlePermissionRequest(extension_a_, {permission_b});
+  // prompt1 resolves both permission requests (second permission request
+  // doesn't show a prompt as permission_b is already prompted by first
+  // permission request).
+  prompt1->Resolve(Result::ACCEPTED);
+  EXPECT_TRUE(allowed_permissions_[0].Equals({permission_a, permission_b}));
+  EXPECT_TRUE(allowed_permissions_[1].Equals({permission_b}));
+}
+
+TEST_F(PublicSessionPermissionHelperTest, TestTwoPromptsB) {
+  auto prompt1 = CallHandlePermissionRequest(extension_a_, {permission_a});
+  auto prompt2 =
+      CallHandlePermissionRequest(extension_a_, {permission_a, permission_b});
+  // prompt2 resolves only permission_b because prompt1 already prompted for
+  // permission_a.
+  prompt2->Resolve(Result::ACCEPTED);
+  EXPECT_EQ(allowed_permissions_.size(), 0u);
+  prompt1->Resolve(Result::ACCEPTED);
+  EXPECT_TRUE(allowed_permissions_[0].Equals({permission_a}));
+  EXPECT_TRUE(allowed_permissions_[1].Equals({permission_a, permission_b}));
+}
+
+TEST_F(PublicSessionPermissionHelperTest, TestTwoPromptsDeny) {
+  auto prompt1 = CallHandlePermissionRequest(extension_a_, {permission_a});
+  auto prompt2 =
+      CallHandlePermissionRequest(extension_a_, {permission_a, permission_b});
+  prompt1->Resolve(Result::USER_CANCELED);
+  EXPECT_TRUE(allowed_permissions_[0].Equals({}));
+  prompt2->Resolve(Result::ACCEPTED);
+  EXPECT_TRUE(allowed_permissions_[1].Equals({permission_b}));
+}
+
+}  // namespace permission_helper
+}  // namespace extensions