The command line flag is now set during the test startup.

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 <stddef.h>
 #include <utility>
 
 #include "base/at_exit.h"
@@ skipping 185 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_(*base::CommandLine::ForCurrentProcess()) {
-    base::CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kEnableExperimentalExtensionApis);
-  }
-
-  ~ScopedExperimentalCommandLine() {
-    *base::CommandLine::ForCurrentProcess() = saved_;
-  }
-
- private:
-  base::CommandLine saved_;
-};
-
 }  // namespace
 
 class ExtensionCrxInstallerTest : public ExtensionBrowserTest {
  protected:
   scoped_ptr<WebstoreInstaller::Approval> GetApproval(
       const char* manifest_dir,
       const std::string& id,
       bool strict_manifest_checks) {
     scoped_ptr<WebstoreInstaller::Approval> result;
 
@@ skipping 38 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) {
-    ScopedExperimentalCommandLine scope;
-
     scoped_ptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
     InstallWithPrompt("browsertest/scopes", std::string(), mock_prompt.get());
 
     scoped_ptr<const 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;
-  }
-
   void InstallWebAppAndVerifyNoErrors() {
     ExtensionService* service =
         extensions::ExtensionSystem::Get(browser()->profile())
             ->extension_service();
     scoped_refptr<CrxInstaller> crx_installer(
         CrxInstaller::CreateSilent(service));
     crx_installer->set_error_on_unsupported_requirements(true);
     crx_installer->InstallWebApp(
         CreateWebAppInfo(kAppTitle, kAppDescription, kAppUrl, 64));
     EXPECT_TRUE(WaitForCrxInstallerDone());
     ASSERT_TRUE(crx_installer->extension());
     ASSERT_FALSE(HasRequirementErrors(crx_installer.get()));
     ASSERT_FALSE(HasPolicyErrors(crx_installer.get()));
   }
 
   bool HasRequirementErrors(CrxInstaller* crx_installer) {
     return !crx_installer->install_checker_.requirement_errors().empty();
   }
 
   bool HasPolicyErrors(CrxInstaller* crx_installer) {
     return !crx_installer->install_checker_.policy_error().empty();
   }
 };
 
+class ExtensionCrxInstallerTestWithExperimentalApis
+    : public ExtensionCrxInstallerTest {
+ protected:
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    ExtensionCrxInstallerTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(switches::kEnableExperimentalExtensionApis);
+  }
+};
+
 // 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_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
   InstallWithPrompt("uitest/plugins", id, mock_prompt.get());
   EXPECT_FALSE(mock_prompt->confirmation_requested());
   EXPECT_TRUE(registry->enabled_extensions().GetByID(id));
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
                        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);
+  const Extension* extension = InstallExtensionFromWebstore(
+      test_data_dir_.AppendASCII("experimental.crx"), 1);
   ASSERT_TRUE(extension);
   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
       APIPermission::kExperimental));
 }
 
 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);
+  const Extension* extension = InstallExtension(
+      test_data_dir_.AppendASCII("experimental.crx"), 1);
   ASSERT_TRUE(extension);
   EXPECT_FALSE(extension->permissions_data()->HasAPIPermission(
       APIPermission::kExperimental));
 }
 
-IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTestWithExperimentalApis,
                        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);
+  const Extension* extension = InstallExtension(
+      test_data_dir_.AppendASCII("experimental.crx"), 1);
   ASSERT_TRUE(extension);
   EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
       APIPermission::kExperimental));
 }
 
-IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, PlatformAppCrx) {
-  ScopedExperimentalCommandLine scope;
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTestWithExperimentalApis,
+                       PlatformAppCrx) {
   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 28 matching lines @@
   LOG(ERROR) << "PackAndInstallExtension: Extension install confirmed";
 }
 
 // Tests that scopes are only granted if |record_oauth2_grant_| on the prompt is
 // true.
 #if defined(OS_WIN)
 #define MAYBE_GrantScopes DISABLED_GrantScopes
 #else
 #define MAYBE_GrantScopes GrantScopes
 #endif
-IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, MAYBE_GrantScopes) {
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTestWithExperimentalApis,
+                       MAYBE_GrantScopes) {
   EXPECT_NO_FATAL_FAILURE(CheckHasEmptyScopesAfterInstall("browsertest/scopes",
                                                           true));
 }
 
-IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, DoNotGrantScopes) {
+IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTestWithExperimentalApis,
+                       DoNotGrantScopes) {
   EXPECT_NO_FATAL_FAILURE(CheckHasEmptyScopesAfterInstall("browsertest/scopes",
                                                           false));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, AllowOffStore) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
   const bool kTestData[] = {false, true};
 
   for (size_t i = 0; i < arraysize(kTestData); ++i) {
@@ skipping 280 matching lines @@
     EXPECT_TRUE(WaitForCrxInstallerDone());
     const Extension* extension = installer->extension();
     ASSERT_TRUE(extension);
     ASSERT_EQ(extension_id, extension->id());
     EXPECT_TRUE(ExtensionPrefs::Get(profile())->AllowFileAccess(extension_id));
     EXPECT_TRUE(extension->creation_flags() & Extension::ALLOW_FILE_ACCESS);
   }
 }
 
 }  // namespace extensions