Support extension update dwnloads which require auth

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 98 matching lines @@
   false,
 };
 
 const char kEmptyUpdateUrlData[] = "";
 
 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);
 
 class MockExtensionDownloaderDelegate : public ExtensionDownloaderDelegate {
  public:
   MOCK_METHOD4(OnExtensionDownloadFailed, void(const std::string&,
                                                Error,
                                                const PingResult&,
                                                const std::set<int>&));
   MOCK_METHOD7(OnExtensionDownloadFinished, void(const std::string&,
@@ skipping 911 matching lines @@
 
     // Expect that ExtensionUpdater asked the mock extensions service to install
     // a file with the test data for the right id.
     EXPECT_EQ(id, service->extension_id());
     base::FilePath tmpfile_path = service->install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(test_url, service->download_url());
     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) {
+    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();
+    ResetDownloader(
+        &updater,
+        new ExtensionDownloader(&updater, service->request_context()));
+    updater.downloader_->extensions_queue_.set_backoff_policy(
+        &kNoBackoffPolicy);
+
+    GURL test_url(use_https ? "https://localhost/extension.crx" :
+                              "http://localhost/extension.crx");
+
+    std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    std::string hash;
+    Version version("0.0.1");
+    std::set<int> requests;
+    requests.insert(0);
+    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
+        new ExtensionDownloader::ExtensionFetch(
+            id, test_url, hash, version.GetString(), requests));
+    updater.downloader_->FetchUpdatedExtension(fetch.Pass());
+
+    fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
+    EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
+
+    // Fake a 403 response.
+    fetcher->set_url(test_url);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(403);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+    RunUntilIdle();
+
+    // Verify that the fetcher has been switched to protected download mode
+    // so that cookies would be sent with the next request (https only).
+    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.
+    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
+      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());
+      base::FilePath tmpfile_path = service->install_path();
+      EXPECT_FALSE(tmpfile_path.empty());
+      EXPECT_EQ(test_url, service->download_url());
+      EXPECT_EQ(extension_file_path, tmpfile_path);
+    }
+  }
+
   // Two extensions are updated.  If |updates_start_running| is true, the
   // mock extensions service has UpdateExtension(...) return true, and
   // the test is responsible for creating fake CrxInstallers.  Otherwise,
   // UpdateExtension() returns false, signaling install failures.
   void TestMultipleExtensionDownloading(bool updates_start_running) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     ServiceForDownloadTests service(prefs_.get());
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
@@ skipping 387 matching lines @@
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingWithRetry) {
   TestSingleExtensionDownloading(false, true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingPendingWithRetry) {
   TestSingleExtensionDownloading(true, true);
 }
 
+TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloading) {
+  TestSingleProtectedExtensionDownloading(true, false);
+}
+
+TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloadingFailure) {
+  TestSingleProtectedExtensionDownloading(true, true);
+}
+
+TEST_F(ExtensionUpdaterTest, TestSingleProtectedExtensionDownloadingNoHTTPS) {
+  TestSingleProtectedExtensionDownloading(false, false);
+}
+
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
   TestMultipleExtensionDownloading(false);
 }
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
   TestMultipleExtensionDownloading(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestRetryDownloading) {
   TestManifestRetryDownloading();
 }
@@ skipping 173 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