Reland: Factor Chrome details out of update manifest fetching.

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 12 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/browser/extensions/updater/chrome_extension_downloader_factory.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
 #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_brand.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/crx_file/id_util.h"
 #include "components/omaha_query_params/omaha_query_params.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_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/updater/manifest_fetch_data.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "google_apis/gaia/fake_identity_provider.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "libxml/globals.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.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/users/scoped_test_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;
+using omaha_query_params::OmahaQueryParams;
 using testing::DoAll;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::_;
 
 namespace extensions {
 
@@ skipping 261 matching lines @@
   }
 
  protected:
   TestExtensionPrefs* const prefs_;
   TestingProfile profile_;
   PendingExtensionManager pending_extension_manager_;
 
  private:
   scoped_ptr<ExtensionDownloader> CreateExtensionDownloader(
       ExtensionDownloaderDelegate* delegate) {
-    return make_scoped_ptr(new ExtensionDownloader(
+    return ChromeExtensionDownloaderFactory::CreateForRequestContext(
+        request_context(),
         downloader_delegate_override_ ? downloader_delegate_override_
-            : delegate,
-        request_context()));
+                                      : delegate);
   }
 
   scoped_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
       ExtensionDownloaderDelegate* delegate) {
     scoped_ptr<FakeIdentityProvider> fake_identity_provider;
     fake_token_service_.reset(new FakeOAuth2TokenService());
     fake_identity_provider.reset(new FakeIdentityProvider(
           fake_token_service_.get()));
     fake_identity_provider->LogIn(kFakeAccountId);
     fake_token_service_->AddAccount(kFakeAccountId);
@@ skipping 187 matching lines @@
     }
   }
 }
 
 static void VerifyQueryAndExtractParameters(
     const std::string& query,
     std::map<std::string, std::string>* result) {
   std::map<std::string, std::string> params;
   ExtractParameters(query, &params);
 
-  std::string omaha_params = omaha_query_params::OmahaQueryParams::Get(
-      omaha_query_params::OmahaQueryParams::CRX);
+  std::string omaha_params = OmahaQueryParams::Get(OmahaQueryParams::CRX);
   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(
@@ skipping 113 matching lines @@
     }
     EXPECT_EQ("", params["uc"]);
   }
 
   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(
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
+    fetch_data->AddExtension(
         id, version, &kNeverPingedData, std::string(), std::string(), false);
 
     std::map<std::string, std::string> params;
-    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &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(
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
+    fetch_data->AddExtension(
         id, version, &kNeverPingedData, "bar", std::string(), false);
     std::map<std::string, std::string> params;
-    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &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(
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
+    fetch_data->AddExtension(
         id, version, &kNeverPingedData, "a=1&b=2&c", std::string(), false);
     std::map<std::string, std::string> params;
-    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &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;
@@ skipping 19 matching lines @@
     std::string::size_type ap = update_url.find("ap%3D", x);
     EXPECT_EQ(std::string::npos, ap);
   }
 
   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, false);
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
+    fetch_data->AddExtension(id, version, &kNeverPingedData,
+                             kEmptyUpdateUrlData, install_source, false);
     std::map<std::string, std::string> params;
-    VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &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;
     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);
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
     UpdateManifest::Results updates;
     std::vector<int> updateable;
-    downloader.DetermineUpdates(fetch_data, updates, &updateable);
+    downloader.DetermineUpdates(*fetch_data, updates, &updateable);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
     // installed and available at v2.0).
     const std::string id1 = crx_file::id_util::GenerateId("1");
     const std::string id2 = crx_file::id_util::GenerateId("2");
-    fetch_data.AddExtension(
+    fetch_data->AddExtension(
         id1, "1.0.0.0", &kNeverPingedData, kEmptyUpdateUrlData, std::string(),
         false);
     AddParseResult(id1, "1.1", "http://localhost/e1_1.1.crx", &updates);
-    fetch_data.AddExtension(
+    fetch_data->AddExtension(
         id2, "2.0.0.0", &kNeverPingedData, kEmptyUpdateUrlData, std::string(),
         false);
     AddParseResult(id2, "2.0.0.0", "http://localhost/e2_2.0.crx", &updates);
 
     EXPECT_CALL(delegate, IsExtensionPending(_)).WillRepeatedly(Return(false));
     EXPECT_CALL(delegate, GetExtensionExistingVersion(id1, _))
         .WillOnce(DoAll(SetArgPointee<1>("1.0.0.0"),
                         Return(true)));
     EXPECT_CALL(delegate, GetExtensionExistingVersion(id2, _))
         .WillOnce(DoAll(SetArgPointee<1>("2.0.0.0"),
                         Return(true)));
 
-    downloader.DetermineUpdates(fetch_data, updates, &updateable);
+    downloader.DetermineUpdates(*fetch_data, updates, &updateable);
     EXPECT_EQ(1u, updateable.size());
     EXPECT_EQ(0, updateable[0]);
   }
 
   void TestDetermineUpdatesPending() {
     // Create a set of test extensions
     ServiceForManifestTests service(prefs_.get());
     PendingExtensionManager* pending_extension_manager =
         service.pending_extension_manager();
     SetupPendingExtensionManagerForTest(3, GURL(), pending_extension_manager);
 
     TestingProfile profile;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
-    ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(GURL("http://localhost/foo")));
     UpdateManifest::Results updates;
 
     std::list<std::string> ids_for_update_check;
     pending_extension_manager->GetPendingIdsForUpdateCheck(
         &ids_for_update_check);
 
     std::list<std::string>::const_iterator it;
     for (it = ids_for_update_check.begin();
          it != ids_for_update_check.end(); ++it) {
-      fetch_data.AddExtension(*it,
-                              "1.0.0.0",
-                              &kNeverPingedData,
-                              kEmptyUpdateUrlData,
-                              std::string(),
-                              false);
+      fetch_data->AddExtension(*it,
+                               "1.0.0.0",
+                               &kNeverPingedData,
+                               kEmptyUpdateUrlData,
+                               std::string(),
+                               false);
       AddParseResult(*it, "1.1", "http://localhost/e1_1.1.crx", &updates);
     }
 
     // The delegate will tell the downloader that all the extensions are
     // pending.
     EXPECT_CALL(delegate, IsExtensionPending(_)).WillRepeatedly(Return(true));
 
     std::vector<int> updateable;
-    downloader.DetermineUpdates(fetch_data, updates, &updateable);
+    downloader.DetermineUpdates(*fetch_data, updates, &updateable);
     // All the apps should be updateable.
     EXPECT_EQ(3u, updateable.size());
     for (std::vector<int>::size_type i = 0; i < updateable.size(); ++i) {
       EXPECT_EQ(static_cast<int>(i), updateable[i]);
     }
   }
 
   void TestMultipleManifestDownloading() {
     net::TestURLFetcherFactory factory;
     factory.set_remove_fetcher_on_delete(true);
     net::TestURLFetcher* fetcher = NULL;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
-    scoped_ptr<ManifestFetchData> fetch1(new ManifestFetchData(kUpdateUrl, 0));
-    scoped_ptr<ManifestFetchData> fetch2(new ManifestFetchData(kUpdateUrl, 0));
-    scoped_ptr<ManifestFetchData> fetch3(new ManifestFetchData(kUpdateUrl, 0));
-    scoped_ptr<ManifestFetchData> fetch4(new ManifestFetchData(kUpdateUrl, 0));
+    scoped_ptr<ManifestFetchData> fetch1(CreateManifestFetchData(kUpdateUrl));
+    scoped_ptr<ManifestFetchData> fetch2(CreateManifestFetchData(kUpdateUrl));
+    scoped_ptr<ManifestFetchData> fetch3(CreateManifestFetchData(kUpdateUrl));
+    scoped_ptr<ManifestFetchData> fetch4(CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true);
     fetch1->AddExtension(
         "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
     fetch2->AddExtension(
         "2222", "2.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
     fetch3->AddExtension(
         "3333", "3.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
     fetch4->AddExtension(
         "4444", "4.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
 
@@ skipping 116 matching lines @@
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     NotificationsObserver observer;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
-    scoped_ptr<ManifestFetchData> fetch(new ManifestFetchData(kUpdateUrl, 0));
+    scoped_ptr<ManifestFetchData> fetch(CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true);
     fetch->AddExtension(
         "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(fetch.Pass());
     RunUntilIdle();
 
     // ExtensionDownloader should retry kMaxRetries times and then fail.
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     for (int i = 0; i <= ExtensionDownloader::kMaxRetries; ++i) {
       // All fetches will fail.
       fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
       EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
       fetcher->set_url(kUpdateUrl);
       fetcher->set_status(net::URLRequestStatus());
       // Code 5xx causes ExtensionDownloader to retry.
       fetcher->set_response_code(500);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
       RunUntilIdle();
     }
     Mock::VerifyAndClearExpectations(&delegate);
 
 
     // For response codes that are not in the 5xx range ExtensionDownloader
     // should not retry.
-    fetch.reset(new ManifestFetchData(kUpdateUrl, 0));
+    fetch.reset(CreateManifestFetchData(kUpdateUrl));
     fetch->AddExtension(
         "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string(), false);
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(fetch.Pass());
     RunUntilIdle();
 
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     // The first fetch will fail, and require retrying.
@@ skipping 634 matching lines @@
     ExtensionUpdater updater(&service,
                              service.extension_prefs(),
                              service.pref_service(),
                              service.profile(),
                              kUpdateFrequencySecs,
                              NULL,
                              service.GetDownloaderFactory());
     updater.Start();
     updater.EnsureDownloaderCreated();
 
-    ManifestFetchData fetch_data(update_url, 0);
+    scoped_ptr<ManifestFetchData> fetch_data(
+        CreateManifestFetchData(update_url));
     const Extension* extension = tmp[0].get();
-    fetch_data.AddExtension(extension->id(),
-                            extension->VersionString(),
-                            &kNeverPingedData,
-                            kEmptyUpdateUrlData,
-                            std::string(),
-                            false);
+    fetch_data->AddExtension(extension->id(),
+                             extension->VersionString(),
+                             &kNeverPingedData,
+                             kEmptyUpdateUrlData,
+                             std::string(),
+                             false);
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
 
-    updater.downloader_->HandleManifestResults(fetch_data, &results);
+    updater.downloader_->HandleManifestResults(*fetch_data, &results);
     Time last_ping_day =
         service.extension_prefs()->LastPingDay(extension->id());
     EXPECT_FALSE(last_ping_day.is_null());
     int64 seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
   }
 
  protected:
   scoped_ptr<TestExtensionPrefs> prefs_;
 
+  ManifestFetchData* CreateManifestFetchData(const GURL& update_url) {
+    return new ManifestFetchData(update_url,
+                                 0,
+                                 "",
+                                 OmahaQueryParams::Get(OmahaQueryParams::CRX),
+                                 ManifestFetchData::PING);
+  }
+
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 };
@@ skipping 264 matching lines @@
   ASSERT_TRUE(fetcher);
   EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 }
 
 TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
   net::TestURLFetcherFactory factory;
   MockService service(prefs_.get());
   MockExtensionDownloaderDelegate delegate;
   ExtensionDownloader downloader(&delegate, service.request_context());
 
-  StartUpdateCheck(&downloader, new ManifestFetchData(GURL(), 0));
+  StartUpdateCheck(&downloader, CreateManifestFetchData(GURL()));
   // This should delete the newly-created ManifestFetchData.
-  StartUpdateCheck(&downloader, new ManifestFetchData(GURL(), 0));
+  StartUpdateCheck(&downloader, CreateManifestFetchData(GURL()));
   // This should add into |manifests_pending_|.
-  StartUpdateCheck(&downloader, new ManifestFetchData(GURL(
-      GURL("http://www.google.com")), 0));
+  StartUpdateCheck(&downloader,
+                   CreateManifestFetchData(GURL("http://www.google.com")));
   // The dtor of |downloader| should delete the pending fetchers.
 }
 
 TEST_F(ExtensionUpdaterTest, TestCheckSoon) {
   ServiceForManifestTests service(prefs_.get());
   net::TestURLFetcherFactory factory;
   ExtensionUpdater updater(&service,
                            service.extension_prefs(),
                            service.pref_service(),
                            service.profile(),
@@ skipping 19 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