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

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 389 matching lines @@
       EXPECT_STREQ(version->GetString().c_str(), v2->GetString().c_str());
       EXPECT_EQ(Manifest::EXTERNAL_PREF, location);
 
       // Remove it so we won't count it ever again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
 
   virtual bool OnExternalExtensionUpdateUrlFound(
-      const std::string& id, const GURL& update_url,
+      const std::string& id,
+      const std::string& install_parameter,
+      const GURL& update_url,
       Manifest::Location location,
       int creation_flags,
       bool mark_acknowledged) OVERRIDE {
     ++ids_found_;
     base::DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << L"Got back ID (" << id.c_str() << ") we weren't expecting";
     EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location);
 
     if (pref) {
       EXPECT_TRUE(provider_->HasExtension(id));
 
       // External extensions with update URLs do not have versions.
       scoped_ptr<Version> v1;
       Manifest::Location location1 = Manifest::INVALID_LOCATION;
       EXPECT_TRUE(provider_->GetExtensionDetails(id, &location1, &v1));
       EXPECT_FALSE(v1.get());
       EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
 
+      std::string parsed_install_parameter;
+      pref->GetString("install_parameter", &parsed_install_parameter);
+      EXPECT_EQ(parsed_install_parameter, install_parameter);
+
       // Remove it so we won't count it again.
       prefs_->Remove(id, NULL);
     }
     return true;
   }
 
   virtual void OnExternalProviderReady(
       const extensions::ExternalProviderInterface* provider) OVERRIDE {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
@@ skipping 1373 matching lines @@
                                          path, Manifest::EXTERNAL_PREF,
                                          Extension::NO_FLAGS, false);
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "location",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try adding the same extension from an external update URL.
   ASSERT_FALSE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       good_crx,
+      std::string(),
       GURL("http:://fake.update/url"),
       Manifest::EXTERNAL_PREF_DOWNLOAD,
       Extension::NO_FLAGS,
       false));
 
   ASSERT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 // Test that uninstalling an external extension does not crash when
 // the extension could not be loaded.
@@ skipping 1354 matching lines @@
 #define MAYBE_UpdatePendingExternalCrx DISABLED_UpdatePendingExternalCrx
 #else
 #define MAYBE_UpdatePendingExternalCrx UpdatePendingExternalCrx
 #endif
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  In this case we don't know if the CRX is a theme
 // or not.
 TEST_F(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-      theme_crx, GURL(), Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS,
+      theme_crx,
+      std::string(),
+      GURL(),
+      Manifest::EXTERNAL_PREF_DOWNLOAD,
+      Extension::NO_FLAGS,
       false));
 
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   base::FilePath path = data_dir_.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
@@ skipping 18 matching lines @@
       kGoodInstallSilently));
 
   // Check that there is a pending crx, with is_from_sync set to true.
   const extensions::PendingExtensionInfo* pending_extension_info;
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_TRUE(pending_extension_info->is_from_sync());
 
   // Add a crx to be updated, with the same ID, from a non-sync source.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-      kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_PREF_DOWNLOAD,
-      Extension::NO_FLAGS, false));
+      kGoodId,
+      std::string(),
+      GURL(kGoodUpdateURL),
+      Manifest::EXTERNAL_PREF_DOWNLOAD,
+      Extension::NO_FLAGS,
+      false));
 
   // Check that there is a pending crx, with is_from_sync set to false.
   ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
       GetById(kGoodId)));
   EXPECT_FALSE(pending_extension_info->is_from_sync());
   EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
             pending_extension_info->install_source());
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_FALSE(service_->pending_extension_manager()->AddFromSync(
@@ skipping 66 matching lines @@
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   const Extension* good = InstallCRX(path, INSTALL_NEW);
   ASSERT_EQ(1u, registry_->enabled_extensions().size());
 
   EXPECT_FALSE(good->is_theme());
 
   // Use AddExtensionImpl() as AddFrom*() would balk.
   service_->pending_extension_manager()->AddExtensionImpl(
-      good->id(), extensions::ManifestURL::GetUpdateURL(good),
-      Version(), &IsExtension, kGoodIsFromSync,
-      kGoodInstallSilently, Manifest::INTERNAL,
-      Extension::NO_FLAGS, false);
+      good->id(),
+      std::string(),
+      extensions::ManifestURL::GetUpdateURL(good),
+      Version(),
+      &IsExtension,
+      kGoodIsFromSync,
+      kGoodInstallSilently,
+      Manifest::INTERNAL,
+      Extension::NO_FLAGS,
+      false);
   UpdateExtension(good->id(), path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 }
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests blacklisting then unblacklisting extensions after the service has been
 // initialized.
 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
   extensions::TestBlacklist test_blacklist;
@@ skipping 1680 matching lines @@
       "{"
       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
       "    \"external_crx\": \"RandomExtension.crx\","
       "    \"external_version\": \"1.0\""
       "  },"
       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
       "    \"external_crx\": \"RandomExtension2.crx\","
       "    \"external_version\": \"2.0\""
       "  },"
       "  \"cccccccccccccccccccccccccccccccc\": {"
-      "    \"external_update_url\": \"http:\\\\foo.com/update\""
+      "    \"external_update_url\": \"http:\\\\foo.com/update\","
+      "    \"install_parameter\": \"id\""
       "  }"
       "}";
   EXPECT_EQ(3, visitor.Visit(json_data));
 
   // Simulate an external_extensions.json file that contains seven invalid
   // records:
   // - One that is missing the 'external_crx' key.
   // - One that is missing the 'external_version' key.
   // - One that is specifying .. in the path.
   // - One that specifies both a file and update URL.
@@ skipping 1168 matching lines @@
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   extensions::PendingExtensionManager* pending =
       service_->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Skip install when the location is the same.
-  EXPECT_FALSE(
-      service_->OnExternalExtensionUpdateUrlFound(
-          kGoodId, GURL(kGoodUpdateURL), Manifest::INTERNAL,
-          Extension::NO_FLAGS, false));
+  EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(kGoodId,
+                                                           std::string(),
+                                                           GURL(kGoodUpdateURL),
+                                                           Manifest::INTERNAL,
+                                                           Extension::NO_FLAGS,
+                                                           false));
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // Install when the location has higher priority.
-  EXPECT_TRUE(
-      service_->OnExternalExtensionUpdateUrlFound(
-          kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_POLICY_DOWNLOAD,
-          Extension::NO_FLAGS, false));
+  EXPECT_TRUE(service_->OnExternalExtensionUpdateUrlFound(
+      kGoodId,
+      std::string(),
+      GURL(kGoodUpdateURL),
+      Manifest::EXTERNAL_POLICY_DOWNLOAD,
+      Extension::NO_FLAGS,
+      false));
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   // Try the low priority again.  Should be rejected.
-  EXPECT_FALSE(
-      service_->OnExternalExtensionUpdateUrlFound(
-          kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_PREF_DOWNLOAD,
-          Extension::NO_FLAGS, false));
+  EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(
+      kGoodId,
+      std::string(),
+      GURL(kGoodUpdateURL),
+      Manifest::EXTERNAL_PREF_DOWNLOAD,
+      Extension::NO_FLAGS,
+      false));
   // The existing record should still be present in the pending extension
   // manager.
   EXPECT_TRUE(pending->IsIdPending(kGoodId));
 
   pending->Remove(kGoodId);
 
   // Skip install when the location has the same priority as the installed
   // location.
-  EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(
-      kGoodId, GURL(kGoodUpdateURL), Manifest::INTERNAL,
-      Extension::NO_FLAGS, false));
+  EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(kGoodId,
+                                                           std::string(),
+                                                           GURL(kGoodUpdateURL),
+                                                           Manifest::INTERNAL,
+                                                           Extension::NO_FLAGS,
+                                                           false));
 
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
   Version older_version("0.1.0.0");
   Version newer_version("2.0.0.0");
 
   // We don't want the extension to be installed.  A path that doesn't
   // point to a valid CRX ensures this.
@@ skipping 217 matching lines @@
   EXPECT_FALSE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion123, kInvalidPathToCrx,
           Manifest::EXTERNAL_REGISTRY, kCreationFlags, kDontMarkAcknowledged));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_TRUE(info->version().IsValid());
   EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding the latest version from the webstore overrides a specific version.
   GURL kUpdateUrl("http://example.com/update");
-  EXPECT_TRUE(
-      service_->OnExternalExtensionUpdateUrlFound(
-          kGoodId, kUpdateUrl, Manifest::EXTERNAL_POLICY_DOWNLOAD,
-          Extension::NO_FLAGS, false));
+  EXPECT_TRUE(service_->OnExternalExtensionUpdateUrlFound(
+      kGoodId,
+      std::string(),
+      kUpdateUrl,
+      Manifest::EXTERNAL_POLICY_DOWNLOAD,
+      Extension::NO_FLAGS,
+      false));
   EXPECT_TRUE((info = pending->GetById(kGoodId)));
   EXPECT_FALSE(info->version().IsValid());
 }
 
 // This makes sure we can package and install CRX files that use whitelisted
 // permissions.
 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kWhitelistedExtensionID, test_id);
@@ skipping 23 matching lines @@
 
     // All tests use a single extension.  Put the id and path in member vars
     // that all methods can read.
     crx_id_ = kGoodId;
     crx_path_ = data_dir_.AppendASCII("good.crx");
   }
 
   // Fake an external source adding a URL to fetch an extension from.
   bool AddPendingExternalPrefUrl() {
     return service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-        crx_id_, GURL(), Manifest::EXTERNAL_PREF_DOWNLOAD,
-        Extension::NO_FLAGS, false);
+        crx_id_,
+        std::string(),
+        GURL(),
+        Manifest::EXTERNAL_PREF_DOWNLOAD,
+        Extension::NO_FLAGS,
+        false);
   }
 
   // Fake an external file from external_extensions.json.
   bool AddPendingExternalPrefFileInstall() {
     Version version("1.0.0.0");
 
     return service_->OnExternalExtensionFileFound(
         crx_id_, &version, crx_path_, Manifest::EXTERNAL_PREF,
         Extension::NO_FLAGS, false);
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service_->pending_extension_manager()->AddFromSync(
         crx_id_, GURL(kGoodUpdateURL), &IsExtension, kGoodInstallSilently);
   }
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
     return service_->OnExternalExtensionUpdateUrlFound(
-        crx_id_, GURL(), Manifest::EXTERNAL_POLICY_DOWNLOAD,
-        Extension::NO_FLAGS, false);
+        crx_id_,
+        std::string(),
+        GURL(),
+        Manifest::EXTERNAL_POLICY_DOWNLOAD,
+        Extension::NO_FLAGS,
+        false);
   }
 
   // Get the install source of a pending extension.
   Manifest::Location GetPendingLocation() {
     const extensions::PendingExtensionInfo* info;
     EXPECT_TRUE((info = service_->pending_extension_manager()->
         GetById(crx_id_)));
     return info->install_source();
   }
 
@@ skipping 386 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             registry_->disabled_extensions().GetIDs());
 }