Add support for command line switches to Features, and as proof that it works,

chrome/browser/extensions/crx_installer_browsertest.cc

 // Copyright (c) 2012 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/extensions/crx_installer.h"
 
 #include "base/at_exit.h"
+#include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/extensions/browser_action_test_util.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_prompt_show_params.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
@@ skipping 12 matching lines @@
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install/crx_installer_error.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/file_util.h"
+#include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permission_set.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/extensions/extension_assets_manager_chromeos.h"
 #include "chromeos/chromeos_switches.h"
 #endif
 
@@ skipping 101 matching lines @@
     return "ManagementPolicyMock";
   }
 
   bool UserMayLoad(const Extension* extension,
                    base::string16* error) const override {
     *error = base::UTF8ToUTF16("Dummy error message");
     return false;
   }
 };
 
+// Appends "enable-experimental-extension-apis" to the command line for the
+// lifetime of this class.
+class ScopedExperimentalCommandLine {
+ public:
+  ScopedExperimentalCommandLine() : saved_(*CommandLine::ForCurrentProcess()) {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableExperimentalExtensionApis);
+  }
+
+  ~ScopedExperimentalCommandLine() {
+    *CommandLine::ForCurrentProcess() = saved_;
+  }
+
+ private:
+  CommandLine saved_;
+};
+
 }  // namespace
 
 class ExtensionCrxInstallerTest : public ExtensionBrowserTest {
- public:
+ protected:
   scoped_ptr<WebstoreInstaller::Approval> GetApproval(
       const char* manifest_dir,
       const std::string& id,
       bool strict_manifest_checks) {
     scoped_ptr<WebstoreInstaller::Approval> result;
 
     base::FilePath ext_path = test_data_dir_.AppendASCII(manifest_dir);
     std::string error;
     scoped_ptr<base::DictionaryValue> parsed_manifest(
         file_util::LoadManifest(ext_path, &error));
@@ skipping 36 matching lines @@
     RunCrxInstaller(approval.get(), mock_install_prompt->CreatePrompt(),
                     crx_path);
 
     EXPECT_TRUE(mock_install_prompt->did_succeed());
   }
 
   // Installs an extension and checks that it has scopes granted IFF
   // |record_oauth2_grant| is true.
   void CheckHasEmptyScopesAfterInstall(const std::string& ext_relpath,
                                        bool record_oauth2_grant) {
-    CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kEnableExperimentalExtensionApis);
+    ScopedExperimentalCommandLine scope;
 
     scoped_refptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
     mock_prompt->set_record_oauth2_grant(record_oauth2_grant);
     InstallWithPrompt("browsertest/scopes", std::string(), mock_prompt);
 
     scoped_refptr<PermissionSet> permissions =
         ExtensionPrefs::Get(browser()->profile())
             ->GetGrantedPermissions(mock_prompt->extension_id());
     ASSERT_TRUE(permissions.get());
   }
+
+  // Returns a FilePath to an unpacked "experimental" extension (a test
+  // Extension which requests the "experimental" permission).
+  base::FilePath PackExperimentalExtension() {
+    // We must modify the command line temporarily in order to pack an
+    // extension that requests the experimental permission.
+    ScopedExperimentalCommandLine scope;
+    base::FilePath test_path = test_data_dir_.AppendASCII("experimental");
+    base::FilePath crx_path = PackExtension(test_path);
+    CHECK(!crx_path.empty()) << "Extension not found at " << test_path.value();
+    return crx_path;
+  }
 };
 
 // This test is skipped on ChromeOS because it requires the NPAPI,
 // which is not available on that platform.
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, Whitelisting) {
   std::string id = "hdgllgikmikobbofgnabhfimcfoopgnd";
   ExtensionRegistry* registry = ExtensionRegistry::Get(
       browser()->profile());
 
   // Even whitelisted extensions with NPAPI should not prompt.
   scoped_refptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
   InstallWithPrompt("uitest/plugins", id, mock_prompt);
   EXPECT_FALSE(mock_prompt->confirmation_requested());
   EXPECT_TRUE(registry->enabled_extensions().GetByID(id));
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
-                       GalleryInstallGetsExperimental) {
-  // We must modify the command line temporarily in order to pack an extension
-  // that requests the experimental permission.
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  CommandLine old_command_line = *command_line;
-  command_line->AppendSwitch(switches::kEnableExperimentalExtensionApis);
-  base::FilePath crx_path = PackExtension(
-      test_data_dir_.AppendASCII("experimental"));
-  ASSERT_FALSE(crx_path.empty());
+                       ExperimentalExtensionFromGallery) {
+  // Gallery-installed extensions should have their experimental permission
+  // preserved, since we allow the Webstore to make that decision.
+  base::FilePath crx_path = PackExperimentalExtension();
+  const Extension* extension = InstallExtensionFromWebstore(crx_path, 1);
+  ASSERT_TRUE(extension);
+  EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
+      APIPermission::kExperimental));
+}
 
-  // Now reset the command line so that we are testing specifically whether
-  // installing from webstore enables experimental permissions.
-  *(CommandLine::ForCurrentProcess()) = old_command_line;
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
+                       ExperimentalExtensionFromOutsideGallery) {
+  // Non-gallery-installed extensions should lose their experimental
+  // permission if the flag isn't enabled.
+  base::FilePath crx_path = PackExperimentalExtension();
+  const Extension* extension = InstallExtension(crx_path, 1);
+  ASSERT_TRUE(extension);
+  EXPECT_FALSE(extension->permissions_data()->HasAPIPermission(
+      APIPermission::kExperimental));
+}
 
-  EXPECT_FALSE(InstallExtension(crx_path, 0));
-  EXPECT_TRUE(InstallExtensionFromWebstore(crx_path, 1));
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
+                       ExperimentalExtensionFromOutsideGalleryWithFlag) {
+  // Non-gallery-installed extensions should maintain their experimental
+  // permission if the flag is enabled.
+  base::FilePath crx_path = PackExperimentalExtension();
+  ScopedExperimentalCommandLine scope;
+  const Extension* extension = InstallExtension(crx_path, 1);
+  ASSERT_TRUE(extension);
+  EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
+      APIPermission::kExperimental));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, PlatformAppCrx) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableExperimentalExtensionApis);
+  ScopedExperimentalCommandLine scope;
   EXPECT_TRUE(InstallExtension(
       test_data_dir_.AppendASCII("minimal_platform_app.crx"), 1));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, PackAndInstallExtension) {
   if (!FeatureSwitch::easy_off_store_install()->IsEnabled())
     return;
 
   const int kNumDownloadsExpected = 1;
 
@@ skipping 308 matching lines @@
   // because previously withheld permissions are now being requested.
   enable_scripts_switch.reset();
   extension = InstallExtension(crx_path, -1);
   EXPECT_FALSE(registry->enabled_extensions().GetByID(extension_id));
   EXPECT_TRUE(registry->disabled_extensions().GetByID(extension_id));
   EXPECT_TRUE(ExtensionPrefs::Get(browser()->profile())->GetDisableReasons(
       extension_id) & Extension::DISABLE_PERMISSIONS_INCREASE);
 }
 
 }  // namespace extensions