src/chrome/browser/ui/views/extensions/extension_install_dialog_view_browsertest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/run_loop.h"
   6 #include "base/strings/utf_string_conversions.h"
   7 #include "chrome/browser/extensions/extension_browsertest.h"
   8 #include "chrome/browser/extensions/extension_icon_manager.h"
   9 #include "chrome/browser/extensions/extension_install_prompt.h"
  10 #include "chrome/browser/extensions/extension_install_prompt_experiment.h"
  11 #include "chrome/browser/ui/browser.h"
  12 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  13 #include "chrome/browser/ui/views/constrained_window_views.h"
  14 #include "chrome/browser/ui/views/extensions/extension_install_dialog_view.h"
  15 #include "chrome/browser/ui/webui/extensions/extension_settings_handler.h"
  16 #include "chrome/common/extensions/extension_test_util.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "extensions/common/extension.h"
  19 #include "extensions/common/permissions/permissions_data.h"
  20 #include "extensions/common/test_util.h"
  21 #include "ui/views/controls/scroll_view.h"
  22 #include "ui/views/view.h"
  23 #include "ui/views/widget/widget.h"
  24
  25 // A simple delegate implementation that counts the number of times
  26 // |InstallUIProceed| and |InstallUIAbort| are called.
  27 class MockExtensionInstallPromptDelegate
  28     : public ExtensionInstallPrompt::Delegate {
  29  public:
  30   MockExtensionInstallPromptDelegate()
  31       : proceed_count_(0),
  32         abort_count_(0) {}
  33
  34   // ExtensionInstallPrompt::Delegate overrides.
  35   virtual void InstallUIProceed() OVERRIDE;
  36   virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
  37
  38   int proceed_count() { return proceed_count_; }
  39   int abort_count() { return abort_count_; }
  40
  41  protected:
  42   int proceed_count_;
  43   int abort_count_;
  44 };
  45
  46 void MockExtensionInstallPromptDelegate::InstallUIProceed() {
  47   ++proceed_count_;
  48 }
  49
  50 void MockExtensionInstallPromptDelegate::InstallUIAbort(bool user_initiated) {
  51   ++abort_count_;
  52 }
  53
  54 // This lets us construct the parent for the prompt we're constructing in our
  55 // tests.
  56 class MockExtensionInstallPrompt : public ExtensionInstallPrompt {
  57  public:
  58   explicit MockExtensionInstallPrompt(content::WebContents* web_contents)
  59       : ExtensionInstallPrompt(web_contents), prompt_(NULL) {}
  60   virtual ~MockExtensionInstallPrompt() {}
  61   void set_prompt(ExtensionInstallPrompt::Prompt* prompt) {
  62     prompt_ = prompt;
  63   }
  64   ExtensionInstallPrompt::Prompt* get_prompt() {
  65     return prompt_;
  66   }
  67
  68  private:
  69   ExtensionInstallPrompt::Prompt* prompt_;
  70 };
  71
  72 class ExtensionInstallDialogViewTestBase : public ExtensionBrowserTest {
  73  protected:
  74   explicit ExtensionInstallDialogViewTestBase(
  75       ExtensionInstallPrompt::PromptType prompt_type);
  76   virtual ~ExtensionInstallDialogViewTestBase() {}
  77
  78   virtual void SetUpOnMainThread() OVERRIDE;
  79
  80   ExtensionInstallPrompt::Prompt* prompt() { return prompt_.get(); }
  81   content::WebContents* web_contents() { return web_contents_; }
  82   MockExtensionInstallPromptDelegate* delegate() { return &delegate_; }
  83
  84   void SetPromptPermissions(std::vector<base::string16> permissions);
  85   void SetPromptDetails(std::vector<base::string16> details);
  86   void SetPromptRetainedFiles(std::vector<base::FilePath> files);
  87
  88  private:
  89   const extensions::Extension* extension_;
  90   MockExtensionInstallPrompt* install_prompt_;
  91   scoped_refptr<ExtensionInstallPrompt::Prompt> prompt_;
  92   content::WebContents* web_contents_;
  93   MockExtensionInstallPromptDelegate delegate_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(ExtensionInstallDialogViewTestBase);
  96 };
  97
  98 ExtensionInstallDialogViewTestBase::ExtensionInstallDialogViewTestBase(
  99     ExtensionInstallPrompt::PromptType prompt_type)
 100     : extension_(NULL),
 101       install_prompt_(NULL),
 102       prompt_(new ExtensionInstallPrompt::Prompt(prompt_type)),
 103       web_contents_(NULL) {
 104 }
 105
 106 void ExtensionInstallDialogViewTestBase::SetUpOnMainThread() {
 107   ExtensionBrowserTest::SetUpOnMainThread();
 108
 109   extension_ = ExtensionBrowserTest::LoadExtension(test_data_dir_.AppendASCII(
 110       "install_prompt/permissions_scrollbar_regression"));
 111
 112   web_contents_ = browser()->tab_strip_model()->GetWebContentsAt(0);
 113
 114   install_prompt_ = new MockExtensionInstallPrompt(web_contents_);
 115   install_prompt_->set_prompt(prompt_);
 116   prompt_->set_experiment(ExtensionInstallPromptExperiment::ControlGroup());
 117   prompt_->set_extension(extension_);
 118
 119   scoped_ptr<ExtensionIconManager> icon_manager(new ExtensionIconManager());
 120   const SkBitmap icon_bitmap = icon_manager->GetIcon(extension_->id());
 121   gfx::Image icon = gfx::Image::CreateFrom1xBitmap(icon_bitmap);
 122   prompt_->set_icon(icon);
 123
 124   this->SetPromptPermissions(std::vector<base::string16>());
 125   this->SetPromptDetails(std::vector<base::string16>());
 126   this->SetPromptRetainedFiles(std::vector<base::FilePath>());
 127 }
 128
 129 void ExtensionInstallDialogViewTestBase::SetPromptPermissions(
 130     std::vector<base::string16> permissions) {
 131   prompt_->SetPermissions(permissions);
 132 }
 133
 134 void ExtensionInstallDialogViewTestBase::SetPromptDetails(
 135     std::vector<base::string16> details) {
 136   prompt_->SetPermissionsDetails(details);
 137 }
 138
 139 void ExtensionInstallDialogViewTestBase::SetPromptRetainedFiles(
 140     std::vector<base::FilePath> files) {
 141   prompt_->set_retained_files(files);
 142 }
 143
 144 class ScrollbarTest : public ExtensionInstallDialogViewTestBase {
 145  protected:
 146   ScrollbarTest();
 147   virtual ~ScrollbarTest() {}
 148
 149   bool IsScrollbarVisible();
 150
 151  private:
 152   DISALLOW_COPY_AND_ASSIGN(ScrollbarTest);
 153 };
 154
 155 ScrollbarTest::ScrollbarTest()
 156     : ExtensionInstallDialogViewTestBase(
 157           ExtensionInstallPrompt::PERMISSIONS_PROMPT) {
 158 }
 159
 160 bool ScrollbarTest::IsScrollbarVisible() {
 161   ExtensionInstallPrompt::ShowParams show_params(web_contents());
 162   ExtensionInstallDialogView* dialog = new ExtensionInstallDialogView(
 163       show_params.navigator, delegate(), prompt());
 164
 165   // Create the modal view around the install dialog view.
 166   views::Widget* modal =
 167       CreateBrowserModalDialogViews(dialog, show_params.parent_window);
 168   modal->Show();
 169   content::BrowserThread::GetBlockingPool()->FlushForTesting();
 170   base::RunLoop().RunUntilIdle();
 171
 172   // Check if the vertical scrollbar is visible.
 173   return dialog->scroll_view()->vertical_scroll_bar()->visible();
 174 }
 175
 176 // Tests that a scrollbar _is_ shown for an excessively long extension
 177 // install prompt.
 178 IN_PROC_BROWSER_TEST_F(ScrollbarTest, LongPromptScrollbar) {
 179   base::string16 permission_string(base::ASCIIToUTF16("Test"));
 180   std::vector<base::string16> permissions;
 181   std::vector<base::string16> details;
 182   for (int i = 0; i < 20; i++) {
 183     permissions.push_back(permission_string);
 184     details.push_back(base::string16());
 185   }
 186   this->SetPromptPermissions(permissions);
 187   this->SetPromptDetails(details);
 188   ASSERT_TRUE(IsScrollbarVisible()) << "Scrollbar is not visible";
 189 }
 190
 191 // Tests that a scrollbar isn't shown for this regression case.
 192 // See crbug.com/385570 for details.
 193 IN_PROC_BROWSER_TEST_F(ScrollbarTest, ScrollbarRegression) {
 194   base::string16 permission_string(base::ASCIIToUTF16(
 195       "Read and modify your data on *.facebook.com"));
 196   std::vector<base::string16> permissions;
 197   permissions.push_back(permission_string);
 198   this->SetPromptPermissions(permissions);
 199   std::vector<base::string16> details;
 200   details.push_back(base::string16());
 201   this->SetPromptDetails(details);
 202   ASSERT_FALSE(IsScrollbarVisible()) << "Scrollbar is visible";
 203 }
 204
 205 class ExtensionInstallDialogViewTest
 206     : public ExtensionInstallDialogViewTestBase {
 207  protected:
 208   ExtensionInstallDialogViewTest()
 209       : ExtensionInstallDialogViewTestBase(
 210             ExtensionInstallPrompt::INSTALL_PROMPT) {}
 211   virtual ~ExtensionInstallDialogViewTest() {}
 212
 213  private:
 214   DISALLOW_COPY_AND_ASSIGN(ExtensionInstallDialogViewTest);
 215 };
 216
 217 // Verifies that the delegate is notified when the user selects to accept or
 218 // cancel the install.
 219 IN_PROC_BROWSER_TEST_F(ExtensionInstallDialogViewTest, NotifyDelegate) {
 220   {
 221     // The user confirms the install.
 222     MockExtensionInstallPromptDelegate delegate;
 223     scoped_ptr<ExtensionInstallDialogView> dialog(
 224         new ExtensionInstallDialogView(web_contents(), &delegate, prompt()));
 225     views::DialogDelegateView* delegate_view = dialog.get();
 226
 227     delegate_view->Accept();
 228     delegate_view->OnClosed();
 229     dialog.reset();
 230
 231     EXPECT_EQ(0, delegate.abort_count());
 232     EXPECT_EQ(1, delegate.proceed_count());
 233   }
 234
 235   {
 236     // The user cancels the install.
 237     MockExtensionInstallPromptDelegate delegate;
 238     scoped_ptr<ExtensionInstallDialogView> dialog(
 239         new ExtensionInstallDialogView(web_contents(), &delegate, prompt()));
 240     views::DialogDelegateView* delegate_view = dialog.get();
 241
 242     delegate_view->Cancel();
 243     delegate_view->OnClosed();
 244     dialog.reset();
 245
 246     EXPECT_EQ(1, delegate.abort_count());
 247     EXPECT_EQ(0, delegate.proceed_count());
 248   }
 249
 250   {
 251     // Corner case: Dialog is closed without the user explicitly choosing to
 252     // proceed or cancel.
 253     MockExtensionInstallPromptDelegate delegate;
 254     scoped_ptr<ExtensionInstallDialogView> dialog(
 255         new ExtensionInstallDialogView(web_contents(), &delegate, prompt()));
 256     dialog.reset();
 257
 258     EXPECT_EQ(1, delegate.abort_count());
 259     EXPECT_EQ(0, delegate.proceed_count());
 260   }
 261 }