src/chrome/browser/extensions/api/management/management_apitest.cc

   1 // Copyright (c) 2012 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 <map>
   6
   7 #include "chrome/browser/chrome_notification_types.h"
   8 #include "chrome/browser/extensions/api/management/management_api.h"
   9 #include "chrome/browser/extensions/extension_apitest.h"
  10 #include "chrome/browser/extensions/extension_service.h"
  11 #include "chrome/browser/extensions/extension_test_message_listener.h"
  12 #include "chrome/browser/extensions/launch_util.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/browser_commands.h"
  16 #include "chrome/browser/ui/browser_finder.h"
  17 #include "chrome/browser/ui/browser_iterator.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/common/chrome_switches.h"
  20 #include "chrome/common/extensions/extension_constants.h"
  21 #include "content/public/test/test_utils.h"
  22 #include "extensions/browser/extension_system.h"
  23 #include "extensions/browser/test_management_policy.h"
  24 #include "extensions/common/manifest.h"
  25
  26 using extensions::Extension;
  27 using extensions::Manifest;
  28
  29 namespace {
  30
  31 // Find a browser other than |browser|.
  32 Browser* FindOtherBrowser(Browser* browser) {
  33   Browser* found = NULL;
  34   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
  35     if (*it == browser)
  36       continue;
  37     found = *it;
  38   }
  39   return found;
  40 }
  41
  42 }  // namespace
  43
  44 class ExtensionManagementApiTest : public ExtensionApiTest {
  45  public:
  46   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  47     ExtensionApiTest::SetUpCommandLine(command_line);
  48     command_line->AppendSwitch(switches::kEnablePanels);
  49   }
  50
  51   virtual void LoadExtensions() {
  52     base::FilePath basedir = test_data_dir_.AppendASCII("management");
  53
  54     // Load 5 enabled items.
  55     LoadNamedExtension(basedir, "enabled_extension");
  56     LoadNamedExtension(basedir, "enabled_app");
  57     LoadNamedExtension(basedir, "description");
  58     LoadNamedExtension(basedir, "permissions");
  59     LoadNamedExtension(basedir, "short_name");
  60
  61     // Load 2 disabled items.
  62     LoadNamedExtension(basedir, "disabled_extension");
  63     DisableExtension(extension_ids_["disabled_extension"]);
  64     LoadNamedExtension(basedir, "disabled_app");
  65     DisableExtension(extension_ids_["disabled_app"]);
  66   }
  67
  68   // Load an app, and wait for a message from app "management/launch_on_install"
  69   // indicating that the new app has been launched.
  70   void LoadAndWaitForLaunch(const std::string& app_path,
  71                             std::string* out_app_id) {
  72     ExtensionTestMessageListener launched_app("launched app", false);
  73     ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(app_path)));
  74
  75     if (out_app_id)
  76       *out_app_id = last_loaded_extension_id();
  77
  78     ASSERT_TRUE(launched_app.WaitUntilSatisfied());
  79   }
  80
  81  protected:
  82   void LoadNamedExtension(const base::FilePath& path,
  83                           const std::string& name) {
  84     const Extension* extension = LoadExtension(path.AppendASCII(name));
  85     ASSERT_TRUE(extension);
  86     extension_ids_[name] = extension->id();
  87   }
  88
  89   void InstallNamedExtension(const base::FilePath& path,
  90                              const std::string& name,
  91                              Manifest::Location install_source) {
  92     const Extension* extension = InstallExtension(path.AppendASCII(name), 1,
  93                                                   install_source);
  94     ASSERT_TRUE(extension);
  95     extension_ids_[name] = extension->id();
  96   }
  97
  98   // Maps installed extension names to their IDs.
  99   std::map<std::string, std::string> extension_ids_;
 100 };
 101
 102 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest, Basics) {
 103   LoadExtensions();
 104
 105   base::FilePath basedir = test_data_dir_.AppendASCII("management");
 106   InstallNamedExtension(basedir, "internal_extension", Manifest::INTERNAL);
 107   InstallNamedExtension(basedir, "external_extension",
 108                         Manifest::EXTERNAL_PREF);
 109   InstallNamedExtension(basedir, "admin_extension",
 110                         Manifest::EXTERNAL_POLICY_DOWNLOAD);
 111
 112   ASSERT_TRUE(RunExtensionSubtest("management/test", "basics.html"));
 113 }
 114
 115 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest, NoPermission) {
 116   LoadExtensions();
 117   ASSERT_TRUE(RunExtensionSubtest("management/no_permission", "test.html"));
 118 }
 119
 120 // Disabled: http://crbug.com/174411
 121 #if defined(OS_WIN)
 122 #define MAYBE_Uninstall DISABLED_Uninstall
 123 #else
 124 #define MAYBE_Uninstall Uninstall
 125 #endif
 126
 127 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest, MAYBE_Uninstall) {
 128   LoadExtensions();
 129   // Confirmation dialog will be shown for uninstallations except for self.
 130   extensions::ManagementUninstallFunction::SetAutoConfirmForTest(true);
 131   ASSERT_TRUE(RunExtensionSubtest("management/test", "uninstall.html"));
 132 }
 133
 134 // Fails often on Windows dbg bots. http://crbug.com/177163
 135 #if defined(OS_WIN)
 136 #define MAYBE_ManagementPolicyAllowed DISABLED_ManagementPolicyAllowed
 137 #else
 138 #define MAYBE_ManagementPolicyAllowed ManagementPolicyAllowed
 139 #endif  // defined(OS_WIN)
 140 // Tests actions on extensions when no management policy is in place.
 141 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest,
 142                        MAYBE_ManagementPolicyAllowed) {
 143   LoadExtensions();
 144   extensions::ManagementUninstallFunction::SetAutoConfirmForTest(true);
 145   ExtensionService* service = extensions::ExtensionSystem::Get(
 146       browser()->profile())->extension_service();
 147   EXPECT_TRUE(service->GetExtensionById(extension_ids_["enabled_extension"],
 148                                         false));
 149
 150   // Ensure that all actions are allowed.
 151   extensions::ExtensionSystem::Get(
 152       browser()->profile())->management_policy()->UnregisterAllProviders();
 153
 154   ASSERT_TRUE(RunExtensionSubtest("management/management_policy",
 155                                   "allowed.html"));
 156   // The last thing the test does is uninstall the "enabled_extension".
 157   EXPECT_FALSE(service->GetExtensionById(extension_ids_["enabled_extension"],
 158                                          true));
 159 }
 160
 161 // Fails often on Windows dbg bots. http://crbug.com/177163
 162 #if defined(OS_WIN)
 163 #define MAYBE_ManagementPolicyProhibited DISABLED_ManagementPolicyProhibited
 164 #else
 165 #define MAYBE_ManagementPolicyProhibited ManagementPolicyProhibited
 166 #endif  // defined(OS_WIN)
 167 // Tests actions on extensions when management policy prohibits those actions.
 168 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest,
 169                        MAYBE_ManagementPolicyProhibited) {
 170   LoadExtensions();
 171   ExtensionService* service = extensions::ExtensionSystem::Get(
 172       browser()->profile())->extension_service();
 173   EXPECT_TRUE(service->GetExtensionById(extension_ids_["enabled_extension"],
 174                                         false));
 175
 176   // Prohibit status changes.
 177   extensions::ManagementPolicy* policy = extensions::ExtensionSystem::Get(
 178       browser()->profile())->management_policy();
 179   policy->UnregisterAllProviders();
 180   extensions::TestManagementPolicyProvider provider(
 181     extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
 182   policy->RegisterProvider(&provider);
 183   ASSERT_TRUE(RunExtensionSubtest("management/management_policy",
 184                                   "prohibited.html"));
 185 }
 186
 187 // Disabled. See http://crbug.com/176023
 188 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest, DISABLED_LaunchPanelApp) {
 189   ExtensionService* service = extensions::ExtensionSystem::Get(
 190       browser()->profile())->extension_service();
 191
 192   // Load an extension that calls launchApp() on any app that gets
 193   // installed.
 194   ExtensionTestMessageListener launcher_loaded("launcher loaded", false);
 195   ASSERT_TRUE(LoadExtension(
 196       test_data_dir_.AppendASCII("management/launch_on_install")));
 197   ASSERT_TRUE(launcher_loaded.WaitUntilSatisfied());
 198
 199   // Load an app with app.launch.container = "panel".
 200   std::string app_id;
 201   LoadAndWaitForLaunch("management/launch_app_panel", &app_id);
 202   ASSERT_FALSE(HasFatalFailure());  // Stop the test if any ASSERT failed.
 203
 204   // Find the app's browser.  Check that it is a popup.
 205   ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
 206                                         browser()->host_desktop_type()));
 207   Browser* app_browser = FindOtherBrowser(browser());
 208   ASSERT_TRUE(app_browser->is_type_popup());
 209   ASSERT_TRUE(app_browser->is_app());
 210
 211   // Close the app panel.
 212   content::WindowedNotificationObserver signal(
 213       chrome::NOTIFICATION_BROWSER_CLOSED,
 214       content::Source<Browser>(app_browser));
 215
 216   chrome::CloseWindow(app_browser);
 217   signal.Wait();
 218
 219   // Unload the extension.
 220   UninstallExtension(app_id);
 221   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 222                                         browser()->host_desktop_type()));
 223   ASSERT_FALSE(service->GetExtensionById(app_id, true));
 224
 225   // Set a pref indicating that the user wants to launch in a regular tab.
 226   // This should be ignored, because panel apps always load in a popup.
 227   extensions::SetLaunchType(service, app_id, extensions::LAUNCH_TYPE_REGULAR);
 228
 229   // Load the extension again.
 230   std::string app_id_new;
 231   LoadAndWaitForLaunch("management/launch_app_panel", &app_id_new);
 232   ASSERT_FALSE(HasFatalFailure());
 233
 234   // If the ID changed, then the pref will not apply to the app.
 235   ASSERT_EQ(app_id, app_id_new);
 236
 237   // Find the app's browser.  Apps that should load in a panel ignore
 238   // prefs, so we should still see the launch in a popup.
 239   ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
 240                                         browser()->host_desktop_type()));
 241   app_browser = FindOtherBrowser(browser());
 242   ASSERT_TRUE(app_browser->is_type_popup());
 243   ASSERT_TRUE(app_browser->is_app());
 244 }
 245
 246 // Disabled: http://crbug.com/230165
 247 #if defined(OS_WIN)
 248 #define MAYBE_LaunchTabApp DISABLED_LaunchTabApp
 249 #else
 250 #define MAYBE_LaunchTabApp LaunchTabApp
 251 #endif
 252 IN_PROC_BROWSER_TEST_F(ExtensionManagementApiTest, MAYBE_LaunchTabApp) {
 253   ExtensionService* service = extensions::ExtensionSystem::Get(
 254       browser()->profile())->extension_service();
 255
 256   // Load an extension that calls launchApp() on any app that gets
 257   // installed.
 258   ExtensionTestMessageListener launcher_loaded("launcher loaded", false);
 259   ASSERT_TRUE(LoadExtension(
 260       test_data_dir_.AppendASCII("management/launch_on_install")));
 261   ASSERT_TRUE(launcher_loaded.WaitUntilSatisfied());
 262
 263   // Code below assumes that the test starts with a single browser window
 264   // hosting one tab.
 265   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 266                                         browser()->host_desktop_type()));
 267   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 268
 269   // Load an app with app.launch.container = "tab".
 270   std::string app_id;
 271   LoadAndWaitForLaunch("management/launch_app_tab", &app_id);
 272   ASSERT_FALSE(HasFatalFailure());
 273
 274   // Check that the app opened in a new tab of the existing browser.
 275   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 276                                         browser()->host_desktop_type()));
 277   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 278
 279   // Unload the extension.
 280   UninstallExtension(app_id);
 281   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 282                                         browser()->host_desktop_type()));
 283   ASSERT_FALSE(service->GetExtensionById(app_id, true));
 284
 285   // Set a pref indicating that the user wants to launch in a window.
 286   extensions::SetLaunchType(service, app_id, extensions::LAUNCH_TYPE_WINDOW);
 287
 288   std::string app_id_new;
 289   LoadAndWaitForLaunch("management/launch_app_tab", &app_id_new);
 290   ASSERT_FALSE(HasFatalFailure());
 291
 292   // If the ID changed, then the pref will not apply to the app.
 293   ASSERT_EQ(app_id, app_id_new);
 294
 295 #if defined(OS_MACOSX)
 296   // App windows are not yet implemented on mac os.  We should fall back
 297   // to a normal tab.
 298   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 299                                         browser()->host_desktop_type()));
 300   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 301 #else
 302   // Find the app's browser.  Opening in a new window will create
 303   // a new browser.
 304   ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
 305                                         browser()->host_desktop_type()));
 306   Browser* app_browser = FindOtherBrowser(browser());
 307   ASSERT_TRUE(app_browser->is_app());
 308 #endif
 309 }