Add chrome version information to extension update checks

chrome/browser/extensions/updater/extension_updater_unittest.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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/extensions/updater/manifest_fetch_data.h"
 #include "chrome/browser/extensions/updater/request_queue_impl.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
+#include "chrome/common/omaha_query_params.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
 #include "libxml/globals.h"
 #include "net/base/backoff_entry.h"
@@ skipping 378 matching lines @@
     if (!key_val.empty()) {
       std::string key = key_val[0];
       EXPECT_TRUE(result->find(key) == result->end());
       (*result)[key] = (key_val.size() == 2) ? key_val[1] : "";
     } else {
       NOTREACHED();
     }
   }
 }
 
+static void VerifyQueryAndExtractParameters(
+    const std::string& query,
+    std::map<std::string, std::string>* result) {
+  std::map<std::string, std::string> params;
+  ExtractParameters(query, &params);
+
+chrome::OmahaQueryParams::ProdId prod =
+#if defined(GOOGLE_CHROME_BUILD)
+  chrome::OmahaQueryParams::CHROMECRX;
+#else
+  chrome::OmahaQueryParams::CHROMIUMCRX;
+#endif
+  std::string omaha_params = chrome::OmahaQueryParams::Get(prod);
+  std::map<std::string, std::string> expected;
+  ExtractParameters(omaha_params, &expected);
+
+  for (std::map<std::string, std::string>::iterator it = expected.begin();
+       it != expected.end(); ++it) {
+    EXPECT_EQ(it->second, params[it->first]);
+  }
+
+  EXPECT_EQ(1U, params.count("x"));
+  std::string decoded = net::UnescapeURLComponent(
+      params["x"], net::UnescapeRule::URL_SPECIAL_CHARS);
+  ExtractParameters(decoded, result);
+}
+
 // All of our tests that need to use private APIs of ExtensionUpdater live
 // inside this class (which is a friend to ExtensionUpdater).
 class ExtensionUpdaterTest : public testing::Test {
  public:
   ExtensionUpdaterTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_),
         io_thread_(BrowserThread::IO, &loop_) {
   }
 
@@ skipping 91 matching lines @@
     net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     const GURL& url = fetcher->GetOriginalURL();
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.SchemeIs("http"));
     EXPECT_EQ("foo.com", url.host());
     EXPECT_EQ("/bar", url.path());
 
     // Validate the extension request parameters in the query. It should
-    // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
+    // look something like "x=id%3D<id>%26v%3D<version>%26uc".
     EXPECT_TRUE(url.has_query());
-    std::vector<std::string> parts;
-    base::SplitString(url.query(), '=', &parts);
-    EXPECT_EQ(2u, parts.size());
-    EXPECT_EQ("x", parts[0]);
-    std::string decoded = net::UnescapeURLComponent(
-        parts[1], net::UnescapeRule::URL_SPECIAL_CHARS);
     std::map<std::string, std::string> params;
-    ExtractParameters(decoded, &params);
+    VerifyQueryAndExtractParameters(url.query(), &params);
     if (pending) {
       EXPECT_TRUE(pending_extension_manager->IsIdPending(params["id"]));
       EXPECT_EQ("0.0.0.0", params["v"]);
     } else {
       EXPECT_EQ(extensions[0]->id(), params["id"]);
       EXPECT_EQ(extensions[0]->VersionString(), params["v"]);
     }
     EXPECT_EQ("", params["uc"]);
   }
 
@@ skipping 19 matching lines @@
     ASSERT_FALSE(fetcher == NULL);
     const GURL& url = fetcher->GetOriginalURL();
 
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.SchemeIs("https"));
     EXPECT_EQ("clients2.google.com", url.host());
     EXPECT_EQ("/service/update2/crx", url.path());
 
     // Validate the extension request parameters in the query. It should
-    // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
+    // look something like "x=id%3D<id>%26v%3D<version>%26uc".
     EXPECT_TRUE(url.has_query());
-    std::vector<std::string> parts;
-    base::SplitString(url.query(), '=', &parts);
-    EXPECT_EQ(2u, parts.size());
-    EXPECT_EQ("x", parts[0]);
-    std::string decoded = net::UnescapeURLComponent(
-        parts[1], net::UnescapeRule::URL_SPECIAL_CHARS);
     std::map<std::string, std::string> params;
-    ExtractParameters(decoded, &params);
+    VerifyQueryAndExtractParameters(url.query(), &params);
     EXPECT_EQ("com.google.crx.blacklist", params["id"]);
     EXPECT_EQ("0", params["v"]);
     EXPECT_EQ("", params["uc"]);
     EXPECT_TRUE(ContainsKey(params, "ping"));
   }
 
   void TestUpdateUrlDataEmpty() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an empty update URL data string does not cause a ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     fetch_data.AddExtension(id, version, &kNeverPingedData, "", "");
-    EXPECT_EQ("http://localhost/foo\?x=id%3Daaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-              "%26v%3D1.0%26uc",
-              fetch_data.full_url().spec());
+
+    std::map<std::string, std::string> params;
+    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
+    EXPECT_EQ(id, params["id"]);
+    EXPECT_EQ(version, params["v"]);
+    EXPECT_EQ(0U, params.count("ap"));
   }
 
   void TestUpdateUrlDataSimple() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     fetch_data.AddExtension(id, version, &kNeverPingedData, "bar", "");
-    EXPECT_EQ("http://localhost/foo\?x=id%3Daaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-              "%26v%3D1.0%26uc%26ap%3Dbar",
-              fetch_data.full_url().spec());
+    std::map<std::string, std::string> params;
+    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
+    EXPECT_EQ(id, params["id"]);
+    EXPECT_EQ(version, params["v"]);
+    EXPECT_EQ("bar", params["ap"]);
   }
 
   void TestUpdateUrlDataCompound() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     fetch_data.AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c", "");
-    EXPECT_EQ("http://localhost/foo\?x=id%3Daaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-              "%26v%3D1.0%26uc%26ap%3Da%253D1%2526b%253D2%2526c",
-              fetch_data.full_url().spec());
+    std::map<std::string, std::string> params;
+    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
+    EXPECT_EQ(id, params["id"]);
+    EXPECT_EQ(version, params["v"]);
+    EXPECT_EQ("a%3D1%26b%3D2%26c", params["ap"]);
   }
 
   void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
     net::TestURLFetcherFactory factory;
 
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     ExtensionList extensions;
     std::string url(gallery_url);
@@ skipping 19 matching lines @@
 
   void TestInstallSource() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
     const std::string install_source = "instally";
 
     // Make sure that an installsource= appears in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     fetch_data.AddExtension(id, version, &kNeverPingedData,
                             kEmptyUpdateUrlData, install_source);
-    EXPECT_EQ("http://localhost/foo\?x=id%3Daaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-              "%26v%3D1.0%26installsource%3Dinstally%26uc",
-              fetch_data.full_url().spec());
+    std::map<std::string, std::string> params;
+    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
+    EXPECT_EQ(id, params["id"]);
+    EXPECT_EQ(version, params["v"]);
+    EXPECT_EQ(install_source, params["installsource"]);
   }
 
   void TestDetermineUpdates() {
     TestingProfile profile;
     profile.CreateRequestContext();
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
@@ skipping 982 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions