Make extension updates use omaha id when talking to omaha.

BUG=b/2168147
TEST=Extensions auto-updates should still work.


Review URL: http://codereview.chromium.org/403026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@32853 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 145 insertions, 1 deletions

diff --git a/chrome/browser/extensions/extension_updater.cc b/chrome/browser/extensions/extension_updater.cc
index a219b0d..a618de9 100644
--- a/chrome/browser/extensions/extension_updater.cc
+++ b/chrome/browser/extensions/extension_updater.cc
@@ -31,6 +31,10 @@
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
+#if defined(OS_WIN)
+#include "base/registry.h"
+#endif
+
 using base::RandDouble;
 using base::RandInt;
 using base::Time;
@@ -48,6 +52,8 @@ const char* ExtensionUpdater::kBlacklistUpdateUrl =
 // Update AppID for extension blacklist.
 const char* ExtensionUpdater::kBlacklistAppID = "com.google.crx.blacklist";
 
+const char* ExtensionUpdater::kUidKey = "uid";
+
 // Wait at least 5 minutes after browser startup before we do any checks. If you
 // change this value, make sure to update comments where it is used.
 const int kStartupWaitSeconds = 60 * 5;
@@ -102,13 +108,41 @@ class ExtensionUpdaterFileHandler
   ~ExtensionUpdaterFileHandler() {}
 };
 
+class DefaultUidProvider : public ExtensionUpdater::UidProvider {
+ public:
+  DefaultUidProvider() {}
+  virtual ~DefaultUidProvider() {}
+
+  virtual std::string GetUidString() {
+    std::string result;
+#if defined(OS_WIN)
+    // First try looking in HKCU, then try HKLM.
+    HKEY rootKeys[] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
+    for (int i = 0; i < sizeof(rootKeys); i++) {
+       RegKey key(rootKeys[i], L"Software\\Google\\Update");
+       std::wstring value;
+       if (key.ReadValue(L"ui", &value)) {
+         if (IsStringASCII(value) &&
+             value.length() <= UidProvider::maxUidLength) {
+           result = WideToASCII(value);
+           break;
+         } else {
+           NOTREACHED();
+         }
+       }
+    }
+#endif
+    return result;
+  }
+};
+
 
 ExtensionUpdater::ExtensionUpdater(ExtensionUpdateService* service,
                                    PrefService* prefs,
                                    int frequency_seconds)
     : service_(service), frequency_seconds_(frequency_seconds),
       prefs_(prefs), file_handler_(new ExtensionUpdaterFileHandler()),
-      blacklist_checks_enabled_(true) {
+      blacklist_checks_enabled_(true), uid_provider_(new DefaultUidProvider()) {
   Init();
 }
 
@@ -527,6 +561,15 @@ void ExtensionUpdater::CheckNow() {
     full_url_string.append(update_url.has_query() ? "&" : "?");
     AppendExtensionInfo(&full_url_string, *extension);
 
+    // Send the Omaha uid when doing update checks to Omaha.
+    if (update_url.DomainIs("google.com")) {
+      std::string uid = uid_provider_->GetUidString();
+      if (uid.length() > 0 && uid.length() <= UidProvider::maxUidLength) {
+        full_url_string.append("&" + std::string(ExtensionUpdater::kUidKey) +
+                               "=" + EscapeQueryParamValue(uid));
+      }
+    }
+
     GURL full_url(full_url_string);
     if (!full_url.is_valid()) {
       LOG(ERROR) << "invalid url: " << full_url.possibly_invalid_spec();
diff --git a/chrome/browser/extensions/extension_updater.h b/chrome/browser/extensions/extension_updater.h
index 84a5a0e..8b2aed1 100644
--- a/chrome/browser/extensions/extension_updater.h
+++ b/chrome/browser/extensions/extension_updater.h
@@ -60,6 +60,19 @@ class ExtensionUpdater
     blacklist_checks_enabled_ = enabled;
   }
 
+  // Interface for getting a uid to send for checks to the gallery.
+  class UidProvider {
+   public:
+    static const unsigned int maxUidLength = 256;
+    virtual ~UidProvider() {}
+
+    // This should return a uid string no longer than maxUidLength, or the empty
+    // string if there is no known uid (in which case nothing will be sent). It
+    // will be url-escaped by the consumer so implementers of this interface
+    // don't need to worry about it.
+    virtual std::string GetUidString() = 0;
+  };
+
  private:
   friend class base::RefCountedThreadSafe<ExtensionUpdater>;
   friend class ExtensionUpdaterTest;
@@ -89,6 +102,9 @@ class ExtensionUpdater
   static const char* kBlacklistUpdateUrl;
   static const char* kBlacklistAppID;
 
+  // Key used to denote Omaha uid in gallery update check urls.
+  static const char* kUidKey;
+
   // Does common work from constructors.
   void Init();
 
@@ -155,6 +171,12 @@ class ExtensionUpdater
   // Creates a blacklist update url.
   static GURL GetBlacklistUpdateUrl(const std::wstring& version);
 
+  // Registers a custom UidProvider, deleting the default one. Takes ownership
+  // of |provider|. Useful mainly for testing.
+  void set_uid_provider(UidProvider* provider) {
+    uid_provider_.reset(provider);
+  }
+
   // Outstanding url fetch requests for manifests and updates.
   scoped_ptr<URLFetcher> manifest_fetcher_;
   scoped_ptr<URLFetcher> extension_fetcher_;
@@ -178,6 +200,8 @@ class ExtensionUpdater
   scoped_refptr<ExtensionUpdaterFileHandler> file_handler_;
   bool blacklist_checks_enabled_;
 
+  scoped_ptr<UidProvider> uid_provider_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionUpdater);
 };
 
diff --git a/chrome/browser/extensions/extension_updater_unittest.cc b/chrome/browser/extensions/extension_updater_unittest.cc
index 2af7b46..e8cb256 100644
--- a/chrome/browser/extensions/extension_updater_unittest.cc
+++ b/chrome/browser/extensions/extension_updater_unittest.cc
@@ -187,6 +187,18 @@ class ServiceForBlacklistTests : public MockService {
 };
 
 
+// For testing gallery updates.
+class MockUidProvider : public ExtensionUpdater::UidProvider {
+ public:
+  explicit MockUidProvider(std::string uid) : uid_(uid) {}
+  virtual ~MockUidProvider() {}
+  virtual std::string GetUidString() {
+    return uid_;
+  }
+ private:
+  std::string uid_;
+};
+
 static const int kUpdateFrequencySecs = 15;
 
 // Takes a string with KEY=VALUE parameters separated by '&' in |params| and
@@ -586,6 +598,68 @@ class ExtensionUpdaterTest : public testing::Test {
     EXPECT_TRUE(extension_data2 == file_contents);
     file_util::Delete(service.install_path(), false);
   }
+
+  static void TestGalleryRequests() {
+    TestURLFetcherFactory factory;
+    URLFetcher::set_factory(&factory);
+
+    // Set up 2 mock extensions, one with a google.com update url and one
+    // without.
+    ServiceForManifestTests service;
+    ExtensionList tmp;
+    GURL url1("http://clients2.google.com/service/update2/crx");
+    GURL url2("http://www.somewebsite.com");
+    CreateTestExtensions(1, &tmp, &url1.possibly_invalid_spec());
+    CreateTestExtensions(1, &tmp, &url2.possibly_invalid_spec());
+    EXPECT_EQ(2u, tmp.size());
+    service.set_extensions(tmp);
+
+    MessageLoop message_loop;
+    ScopedTempPrefService prefs;
+    scoped_refptr<ExtensionUpdater> updater =
+      new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+    updater->set_blacklist_checks_enabled(false);
+
+    // Create a mock uid provider and have the updater take ownership of it.
+    MockUidProvider* uid_provider = new MockUidProvider("foobar");
+    updater->set_uid_provider(uid_provider);
+
+    // Make the updater do manifest fetching, and note the urls it tries to
+    // fetch.
+    std::vector<GURL> fetched_urls;
+    updater->CheckNow();
+    TestURLFetcher* fetcher =
+      factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
+    EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    fetched_urls.push_back(fetcher->original_url());
+    fetcher->delegate()->OnURLFetchComplete(
+      fetcher, fetched_urls[0], URLRequestStatus(), 500, ResponseCookies(), "");
+    fetcher =
+      factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
+    fetched_urls.push_back(fetcher->original_url());
+
+    // The urls could have been fetched in either order, so use the host to
+    // tell them apart and note the query each used.
+    std::string url1_query;
+    std::string url2_query;
+    if (fetched_urls[0].host() == url1.host()) {
+      url1_query = fetched_urls[0].query();
+      url2_query = fetched_urls[1].query();
+    } else if (fetched_urls[0].host() == url2.host()) {
+      url1_query = fetched_urls[1].query();
+      url2_query = fetched_urls[0].query();
+    } else {
+      NOTREACHED();
+    }
+
+    // Now make sure the google query had the uid but the regular one did not.
+    std::string search_string = std::string(ExtensionUpdater::kUidKey) + "=" +
+        uid_provider->GetUidString();
+    EXPECT_TRUE(url1_query.find(search_string) != std::string::npos);
+    EXPECT_TRUE(url2_query.find(search_string) == std::string::npos);
+
+    STLDeleteElements(&tmp);
+  }
 };
 
 // Because we test some private methods of ExtensionUpdater, it's easer for the
@@ -622,6 +696,9 @@ TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloading) {
   ExtensionUpdaterTest::TestMultipleExtensionDownloading();
 }
 
+TEST(ExtensionUpdaterTest, TestGalleryRequests) {
+  ExtensionUpdaterTest::TestGalleryRequests();
+}
 
 // TODO(asargent) - (http://crbug.com/12780) add tests for:
 // -prodversionmin (shouldn't update if browser version too old)