PS - Showing permission prompt for activeTab

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/memory/weak_ptr.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 "chromeos/login/scoped_test_public_session_login_state.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 extensions {
+namespace permission_helper {
 namespace {
 
 auto permission_a = APIPermission::kAudio;
 auto permission_b = APIPermission::kBookmark;
 bool did_show_dialog;
 
+const char kWhitelistedId[] = "cbkkbcmdlboombapidmoeolnmdacpkch";
+const char kNonWhitelistedId[] = "bogus";
+
 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;
 }
 
 bool get_did_show_dialog_and_reset() {
   bool tmp = did_show_dialog;
   did_show_dialog = false;
   return tmp;
 }
 
+base::Callback<void(const PermissionIDSet&)> BindQuitLoop(base::RunLoop* loop) {
+  return base::Bind(
+      [](base::RunLoop* loop, const PermissionIDSet&) { loop->Quit(); }, loop);
+}
+
 class ProgrammableInstallPrompt
     : public ExtensionInstallPrompt,
       public base::SupportsWeakPtr<ProgrammableInstallPrompt> {
  public:
   explicit ProgrammableInstallPrompt(WebContents* contents)
       : ExtensionInstallPrompt(contents) {}
 
   ~ProgrammableInstallPrompt() override {}
 
   void ShowDialog(
@@ skipping 12 matching lines @@
   }
 
  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> ReturnPrompt(
       std::unique_ptr<ExtensionInstallPrompt> prompt,
       WebContents* web_contents);
   base::WeakPtr<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_;
 
+  chromeos::ScopedTestPublicSessionLoginState login_state_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(PublicSessionPermissionHelperTest);
 };
 
 void PublicSessionPermissionHelperTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   extension_a_ = LoadManifestHelper("extension_a");
   extension_b_ = LoadManifestHelper("extension_b");
 }
 
@@ skipping 120 matching lines @@
   auto prompt2 =
       CallHandlePermissionRequest(extension_a_, {permission_a, permission_b});
   EXPECT_TRUE(prompt2);
   EXPECT_TRUE(get_did_show_dialog_and_reset());
   prompt1->Resolve(Result::USER_CANCELED);
   EXPECT_TRUE(allowed_permissions_.at(0).Equals({}));
   prompt2->Resolve(Result::ACCEPTED);
   EXPECT_TRUE(allowed_permissions_.at(1).Equals({permission_b}));
 }
 
+TEST_F(PublicSessionPermissionHelperTest, WhitelistedExtension) {
+  auto extension = LoadManifestHelper(kWhitelistedId);
+  // Whitelisted extension can use any permission.
+  EXPECT_TRUE(PermissionAllowed(extension.get(), permission_a));
+  EXPECT_TRUE(PermissionAllowed(extension.get(), permission_b));
+  // Whitelisted extension is already handled (no permission prompt needed).
+  EXPECT_TRUE(HandlePermissionRequest(*extension, {permission_a},
+                                      web_contents(), RequestResolvedCallback(),
+                                      PromptFactory()));
+  EXPECT_TRUE(PermissionAllowed(extension.get(), permission_a));
+  EXPECT_TRUE(PermissionAllowed(extension.get(), permission_b));
+}
+
+TEST_F(PublicSessionPermissionHelperTest, NonWhitelistedExtension) {
+  auto extension = LoadManifestHelper(kNonWhitelistedId);
+  EXPECT_FALSE(PermissionAllowed(extension.get(), permission_a));
+  EXPECT_FALSE(PermissionAllowed(extension.get(), permission_b));
+  // Prompt for permission_a, grant it, verify.
+  {
+    ScopedTestDialogAutoConfirm auto_confirm(
+        ScopedTestDialogAutoConfirm::ACCEPT);
+    // Permission not handled yet, need to show a prompt.
+    base::RunLoop loop;
+    EXPECT_FALSE(HandlePermissionRequest(*extension, {permission_a},
+                                         web_contents(), BindQuitLoop(&loop),
+                                         PromptFactory()));
+    loop.Run();
+    EXPECT_TRUE(PermissionAllowed(extension.get(), permission_a));
+    EXPECT_FALSE(PermissionAllowed(extension.get(), permission_b));
+  }
+  // Already handled (allow), doesn't show a prompt.
+  EXPECT_TRUE(HandlePermissionRequest(*extension, {permission_a},
+                                      web_contents(), RequestResolvedCallback(),
+                                      PromptFactory()));
+  // Prompt for permission_b, deny it, verify.
+  {
+    ScopedTestDialogAutoConfirm auto_confirm(
+        ScopedTestDialogAutoConfirm::CANCEL);
+    // Permission not handled yet, need to show a prompt.
+    base::RunLoop loop;
+    EXPECT_FALSE(HandlePermissionRequest(*extension, {permission_b},
+                                         web_contents(), BindQuitLoop(&loop),
+                                         PromptFactory()));
+    loop.Run();
+    EXPECT_TRUE(PermissionAllowed(extension.get(), permission_a));
+    EXPECT_FALSE(PermissionAllowed(extension.get(), permission_b));
+  }
+  // Already handled (deny), doesn't show a prompt.
+  EXPECT_TRUE(HandlePermissionRequest(*extension, {permission_b},
+                                      web_contents(), RequestResolvedCallback(),
+                                      PromptFactory()));
+}
+
 }  // namespace permission_helper
 }  // namespace extensions