Introduce an extension parameter which is used to customize the extension. It's available for exter…

chrome/browser/extensions/extension_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/extension_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 106 matching lines @@
     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile, "user");
   }
 #endif
 }
 
 void ExtensionBrowserTest::SetUpOnMainThread() {
   InProcessBrowserTest::SetUpOnMainThread();
   observer_.reset(new ExtensionTestNotificationObserver(browser()));
 }
 
+const Extension* ExtensionBrowserTest::LoadExtension(
+    const base::FilePath& path) {
+  return LoadExtensionWithFlags(path, kFlagEnableFileAccess);
+}
+
+const Extension* ExtensionBrowserTest::LoadExtensionIncognito(
+    const base::FilePath& path) {
+  return LoadExtensionWithFlags(path,
+                                kFlagEnableFileAccess | kFlagEnableIncognito);
+}
+
 const Extension* ExtensionBrowserTest::LoadExtensionWithFlags(
     const base::FilePath& path, int flags) {
+  return LoadExtensionWithInstallParam(path, flags, std::string());
+}
+
+const extensions::Extension*
+ExtensionBrowserTest::LoadExtensionWithInstallParam(
+    const base::FilePath& path,
+    int flags,
+    const std::string& install_param) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       profile())->extension_service();
   {
     observer_->Watch(chrome::NOTIFICATION_EXTENSION_LOADED,
                      content::NotificationService::AllSources());
 
     scoped_refptr<extensions::UnpackedInstaller> installer(
         extensions::UnpackedInstaller::Create(service));
     installer->set_prompt_for_plugins(false);
     installer->set_require_modern_manifest_version(
@@ skipping 23 matching lines @@
       }
 
       EXPECT_TRUE(extension->install_warnings().empty()) <<
           install_warnings_message;
       return NULL;
     }
   }
 
   const std::string extension_id = extension->id();
 
-  // The call to OnExtensionInstalled ensures the other extension prefs
-  // are set up with the defaults.
-  extensions::ExtensionPrefs::Get(profile())
-      ->OnExtensionInstalled(extension,
-                             Extension::ENABLED,
-                             false,
-                             syncer::StringOrdinal::CreateInitialOrdinal());
+  if (!install_param.empty()) {
+    extensions::ExtensionPrefs::Get(profile())
+        ->SetInstallParam(extension_id, install_param);
+    // Re-enable the extension if needed.
+    if (service->extensions()->Contains(extension_id)) {
+      content::WindowedNotificationObserver load_signal(
+          chrome::NOTIFICATION_EXTENSION_LOADED,
+          content::Source<Profile>(profile()));
+      // Reload the extension so that the NOTIFICATION_EXTENSION_LOADED
+      // observers may access |install_param|.

[Yoyo Zhou, 2014/03/18 00:07:51]

I'm struggling to understand the reason for this. Can we call SetInstallParam
earlier, say at line 153?

[vasilii, 2014/03/18 10:01:22]

We don't know its id yet. It'd be ideal if we could install the extension, set
the parameter and then load it.

+      service->ReloadExtension(extension_id);
+      load_signal.Wait();
+      extension = service->GetExtensionById(extension_id, false);
+      CHECK(extension) << extension_id << " not found after reloading.";
+    }
+  }
 
   // Toggling incognito or file access will reload the extension, so wait for
   // the reload and grab the new extension instance. The default state is
   // incognito disabled and file access enabled, so we don't wait in those
   // cases.
   {
     content::WindowedNotificationObserver load_signal(
         chrome::NOTIFICATION_EXTENSION_LOADED,
         content::Source<Profile>(profile()));
     CHECK(!extensions::util::IsIncognitoEnabled(extension_id, profile()));
@@ skipping 18 matching lines @@
       CHECK(extension) << extension_id << " not found after reloading.";
     }
   }
 
   if (!observer_->WaitForExtensionViewsToLoad())
     return NULL;
 
   return extension;
 }
 
-const Extension* ExtensionBrowserTest::LoadExtension(
-    const base::FilePath& path) {
-  return LoadExtensionWithFlags(path, kFlagEnableFileAccess);
-}
-
-const Extension* ExtensionBrowserTest::LoadExtensionIncognito(
-    const base::FilePath& path) {
-  return LoadExtensionWithFlags(path,
-                                kFlagEnableFileAccess | kFlagEnableIncognito);
-}
-
 const Extension* ExtensionBrowserTest::LoadExtensionAsComponentWithManifest(
     const base::FilePath& path,
     const base::FilePath::CharType* manifest_relative_path) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       profile())->extension_service();
 
   std::string manifest;
   if (!base::ReadFileToString(path.Append(manifest_relative_path), &manifest)) {
     return NULL;
   }
@@ skipping 351 matching lines @@
   EXPECT_EQ(expected_hosts, num_hosts);
   return host;
 }
 
 std::string ExtensionBrowserTest::ExecuteScriptInBackgroundPage(
     const std::string& extension_id,
     const std::string& script) {
   return extensions::browsertest_util::ExecuteScriptInBackgroundPage(
       profile(), extension_id, script);
 }