Reland: Support multiple sign-in for extension updates.

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 42 matching lines @@
 #include "extensions/common/id_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "libxml/globals.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/third_party/mozilla/url_parse.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
@@ skipping 33 matching lines @@
   // Time to keep an entry from being discarded even when it
   // has no significant state, -1 to never discard.
   -1,
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 const char kEmptyUpdateUrlData[] = "";
 
+const char kAuthUserQueryKey[] = "authuser";
+
 int kExpectedLoadFlags =
     net::LOAD_DO_NOT_SEND_COOKIES |
     net::LOAD_DO_NOT_SAVE_COOKIES |
     net::LOAD_DISABLE_CACHE;
 
 int kExpectedLoadFlagsForProtectedDownload = net::LOAD_DISABLE_CACHE;
 
 const ManifestFetchData::PingData kNeverPingedData(
     ManifestFetchData::kNeverPinged, ManifestFetchData::kNeverPinged, true);
 
@@ skipping 115 matching lines @@
   }
 
   content::NotificationRegistrar registrar_;
   size_t count_[arraysize(kNotificationsObserved)];
   std::set<std::string> updated_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsObserver);
 };
 
+// Extracts the integer value of the |authuser| query parameter. Returns 0 if
+// the parameter is not set.
+int GetAuthUserQueryValue(const GURL& url) {
+  std::string query_string = url.query();
+  url::Component query(0, query_string.length());
+  url::Component key, value;
+  while (
+      url::ExtractQueryKeyValue(query_string.c_str(), &query, &key, &value)) {
+    std::string key_string = query_string.substr(key.begin, key.len);
+    if (key_string == kAuthUserQueryKey) {
+      int user_index = 0;
+      base::StringToInt(query_string.substr(value.begin, value.len),
+                        &user_index);
+      return user_index;
+    }
+  }
+  return 0;
+}
+
 }  // namespace
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
       : prefs_(prefs), pending_extension_manager_(*this, &profile_) {}
 
   virtual ~MockService() {}
 
@@ skipping 814 matching lines @@
       EXPECT_EQ(id, service->extension_id());
       base::FilePath tmpfile_path = service->install_path();
       EXPECT_FALSE(tmpfile_path.empty());
       EXPECT_EQ(extension_file_path, tmpfile_path);
     }
   }
 
   // Update a single extension in an environment where the download request
   // initially responds with a 403 status. Expect the fetcher to automatically
   // retry with cookies enabled.
-  void TestSingleProtectedExtensionDownloading(bool use_https, bool fail) {
+  void TestSingleProtectedExtensionDownloading(bool use_https,
+                                               bool fail,
+                                               int max_authuser,
+                                               int valid_authuser) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(
         new ServiceForDownloadTests(prefs_.get()));
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs,
                              NULL);
     updater.Start();
@@ skipping 32 matching lines @@
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     if (use_https) {
       EXPECT_TRUE(
           fetcher->GetLoadFlags() == kExpectedLoadFlagsForProtectedDownload);
     } else {
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     }
 
     // Attempt to fetch again after the auth failure.
+    bool succeed = !fail;
     if (fail) {
-      // Fail and verify that the fetch queue is cleared.
-      fetcher->set_url(test_url);
-      fetcher->set_status(net::URLRequestStatus());
-      fetcher->set_response_code(403);
-      fetcher->delegate()->OnURLFetchComplete(fetcher);
-      RunUntilIdle();
-      EXPECT_EQ(0U, updater.downloader_->extensions_queue_.active_request());
-    } else {
-      // Succeed
+      // Do not simulate incremental authuser retries.
+      if (max_authuser == 0) {
+        // Fail and verify that the fetch queue is cleared.
+        fetcher->set_url(test_url);
+        fetcher->set_status(net::URLRequestStatus());
+        fetcher->set_response_code(401);
+        fetcher->delegate()->OnURLFetchComplete(fetcher);
+        RunUntilIdle();
+
+        EXPECT_EQ(0U, updater.downloader_->extensions_queue_.active_request());
+        return;
+      }
+
+      // Simulate incremental authuser retries.
+      for (int user_index = 0; user_index <= max_authuser; ++user_index) {
+        const ExtensionDownloader::ExtensionFetch& fetch =
+            *updater.downloader_->extensions_queue_.active_request();
+        EXPECT_EQ(user_index, GetAuthUserQueryValue(fetch.url));
+        if (user_index == valid_authuser) {
+          succeed = true;
+          break;
+        }
+        fetcher =
+            factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
+        EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+        fetcher->set_url(fetch.url);
+        fetcher->set_status(net::URLRequestStatus());
+        fetcher->set_response_code(403);
+        fetcher->delegate()->OnURLFetchComplete(fetcher);
+        RunUntilIdle();
+      }
+    }
+
+    // Succeed
+    if (succeed) {
+      fetcher =
+          factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
+      EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
       base::FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
       fetcher->set_url(test_url);
       fetcher->set_status(net::URLRequestStatus());
       fetcher->set_response_code(200);
       fetcher->SetResponseFilePath(extension_file_path);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
       RunUntilIdle();
 
       // Verify installation would proceed as normal.
       EXPECT_EQ(id, service->extension_id());
@@ skipping 420 matching lines @@
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingFailureWithRetry) {
   TestSingleExtensionDownloading(false, true, true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingFailurePending) {
   TestSingleExtensionDownloading(true, false, true);
 }
 
-TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloading) {
-  TestSingleProtectedExtensionDownloading(true, false);
+TEST_F(ExtensionUpdaterTest, SingleProtectedExtensionDownloading) {
+  TestSingleProtectedExtensionDownloading(true, false, 0, 0);
 }
 
-TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloadingFailure) {
-  TestSingleProtectedExtensionDownloading(true, true);
+TEST_F(ExtensionUpdaterTest, SingleProtectedExtensionDownloadingFailure) {
+  TestSingleProtectedExtensionDownloading(true, true, 0, 0);
 }
 
-TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloadingNoHTTPS) {
-  TestSingleProtectedExtensionDownloading(false, false);
+TEST_F(ExtensionUpdaterTest, SingleProtectedExtensionDownloadingNoHTTPS) {
+  TestSingleProtectedExtensionDownloading(false, false, 0, 0);
+}
+
+TEST_F(ExtensionUpdaterTest,
+       SingleProtectedExtensionDownloadingWithNonDefaultAuthUser1) {
+  TestSingleProtectedExtensionDownloading(true, true, 2, 1);
+}
+
+TEST_F(ExtensionUpdaterTest,
+       SingleProtectedExtensionDownloadingWithNonDefaultAuthUser2) {
+  TestSingleProtectedExtensionDownloading(true, true, 2, 2);
+}
+
+TEST_F(ExtensionUpdaterTest,
+       SingleProtectedExtensionDownloadingAuthUserExhaustionFailure) {
+  TestSingleProtectedExtensionDownloading(true, true, 2, 5);
 }
 
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
   TestMultipleExtensionDownloading(false);
 }
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
   TestMultipleExtensionDownloading(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestRetryDownloading) {
@@ skipping 174 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