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(const PermissionIDSet& allowed_permissions);
+  std::unique_ptr<ExtensionInstallPrompt> PromptFactory();
+  ProgrammableInstallPrompt* CallHandlePermissionRequest(
+      const scoped_refptr<Extension>& extension,
+      const PermissionIDSet& permissions);
+
+ protected:
+  scoped_refptr<Extension> extension_a_;
+  scoped_refptr<Extension> extension_b_;
+
+  std::vector<PermissionIDSet> allowed_permissions_;
+  ProgrammableInstallPrompt* last_prompt_;
+
+ 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(
+    const PermissionIDSet& allowed_permissions) {
+  allowed_permissions_.push_back(std::move(allowed_permissions));
+}
+
+std::unique_ptr<ExtensionInstallPrompt>
+PublicSessionPermissionHelperTest::PromptFactory() {
+  last_prompt_ = new ProgrammableInstallPrompt(web_contents());
+  return base::WrapUnique<ExtensionInstallPrompt>(last_prompt_);
+}
+
+ProgrammableInstallPrompt*
+PublicSessionPermissionHelperTest::CallHandlePermissionRequest(
+    const scoped_refptr<Extension>& extension,
+    const PermissionIDSet& permissions) {
+  auto factory_callback =
+      base::Bind(&PublicSessionPermissionHelperTest::PromptFactory,
+                 base::Unretained(this));
+  last_prompt_ = nullptr;

[Andrew T Wilson (Slow), 2017/02/10 17:17:21]

It's messy to keep a last_prompt_ member variable just to pass the created
prompt back. It's OK to have this callback be a true factory if you expect it to
be called multiple times, but if you expect it to be called only once by
HandlePermissionRequest then consider just creating ProgrammableInstallPrompt in
this function, and pass in a callback that just returns it.

std::unique_ptr<ExtensionInstallPrompt>
ReturnPrompt(std::unique_ptr<ExtensionInstallPrompt> prompt) {
  return prompt;
}

ProgrammableInstallPrompt* CallHandlePermissionRequest() {
  ProgrammableInstallPrompt* prompt = new
ProgrammalbeInstallPrompt(web_contents());
  auto factory_callback =
base::Bind(&PublicSessionPermissionHelperTest::ReturnPrompt,
      base::WrapUnique<ExtensionInstallPrompt>(prompt));
  HandlePermissionRequest(...)
  return prompt;
}

[Ivan Šandrk, 2017/02/10 18:46:25]

Good point. Done.

+  HandlePermissionRequest(
+      *extension.get(), permissions, web_contents(),
+      base::Bind(&PublicSessionPermissionHelperTest::RequestResolved,
+                 base::Unretained(this)),
+      &factory_callback);
+  return last_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