Send traffic-management headers from extension updater.

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 "chrome/browser/extensions/updater/extension_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 747 matching lines @@
 
   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.
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, std::string(),
-                             std::string());
+                             std::string(), false);
 
     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.
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, "bar",
-                             std::string());
+                             std::string(), false);
     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.
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c",
-                             std::string());
+                             std::string(), false);
     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) {
+  void TestUpdateUrlDataFromGallery(const std::string& gallery_url,
+                                    bool on_demand_update) {
     net::TestURLFetcherFactory factory;
 
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     ExtensionList extensions;
     std::string url(gallery_url);
 
     service.CreateTestExtensions(1, 1, &extensions, &url, Manifest::INTERNAL);
 
     const std::string& id = extensions[0]->id();
     EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
 
-    downloader.AddExtension(*extensions[0], 0);
+    downloader.AddExtension(*extensions[0], 0, on_demand_update);
     downloader.StartAllPending(NULL);
     net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     ASSERT_TRUE(fetcher);
     // Make sure that extensions that update from the gallery ignore any
     // update URL data.
     const std::string& update_url = fetcher->GetOriginalURL().spec();
     std::string::size_type x = update_url.find("x=");
     EXPECT_NE(std::string::npos, x);
     std::string::size_type ap = update_url.find("ap%3D", x);
     EXPECT_EQ(std::string::npos, ap);
+
+    net::HttpRequestHeaders fetch_headers;
+    fetcher->GetExtraRequestHeaders(&fetch_headers);
+    EXPECT_TRUE(fetch_headers.HasHeader(
+        ExtensionDownloader::kUpdateInteractivityHeader));
+    EXPECT_TRUE(
+        fetch_headers.HasHeader(ExtensionDownloader::kUpdateAppIdHeader));
+    EXPECT_TRUE(
+        fetch_headers.HasHeader(ExtensionDownloader::kUpdateUpdaterHeader));
+
+    std::string interactivity_value;
+    fetch_headers.GetHeader(ExtensionDownloader::kUpdateInteractivityHeader,
+                            &interactivity_value);
+    EXPECT_EQ(on_demand_update ? "fg" : "bg", interactivity_value);
+
+    std::string appid_value;
+    fetch_headers.GetHeader(ExtensionDownloader::kUpdateAppIdHeader,
+                            &appid_value);
+    EXPECT_EQ(extensions[0]->id(), appid_value);
+
+    std::string updater_value;
+    fetch_headers.GetHeader(ExtensionDownloader::kUpdateUpdaterHeader,
+                            &updater_value);
+    std::string expected_updater_value = base::StringPrintf(
+        "%s-%s", UpdateQueryParams::GetProdIdString(UpdateQueryParams::CRX),
+        UpdateQueryParams::GetProdVersion().c_str());
+    EXPECT_EQ(expected_updater_value, updater_value);
   }
 
   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.
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData,
-                             kEmptyUpdateUrlData, install_source);
+                             kEmptyUpdateUrlData, install_source, false);
     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;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
     // Check passing an empty list of parse results to DetermineUpdates
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     UpdateManifest::Results updates;
     std::vector<int> 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(id1, "1.0.0.0", &kNeverPingedData,
-                             kEmptyUpdateUrlData, std::string());
+                             kEmptyUpdateUrlData, std::string(), false);
     AddParseResult(id1, "1.1", "http://localhost/e1_1.1.crx", &updates);
     fetch_data->AddExtension(id2, "2.0.0.0", &kNeverPingedData,
-                             kEmptyUpdateUrlData, std::string());
+                             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)));
 
@@ skipping 18 matching lines @@
     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());
+                               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);
     // All the apps should be updateable.
@@ skipping 17 matching lines @@
     std::unique_ptr<ManifestFetchData> fetch1(
         CreateManifestFetchData(kUpdateUrl));
     std::unique_ptr<ManifestFetchData> fetch2(
         CreateManifestFetchData(kUpdateUrl));
     std::unique_ptr<ManifestFetchData> fetch3(
         CreateManifestFetchData(kUpdateUrl));
     std::unique_ptr<ManifestFetchData> fetch4(
         CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true, 0);
     fetch1->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
-                         std::string());
+                         std::string(), false);
     fetch2->AddExtension("2222", "2.0", &zeroDays, kEmptyUpdateUrlData,
-                         std::string());
+                         std::string(), false);
     fetch3->AddExtension("3333", "3.0", &zeroDays, kEmptyUpdateUrlData,
-                         std::string());
+                         std::string(), false);
     fetch4->AddExtension("4444", "4.0", &zeroDays, kEmptyUpdateUrlData,
-                         std::string());
+                         std::string(), false);
 
     // This will start the first fetcher and queue the others. The next in queue
     // is started as each fetcher receives its response. Note that the fetchers
     // don't necessarily run in the order that they are started from here.
     GURL fetch1_url = fetch1->full_url();
     GURL fetch2_url = fetch2->full_url();
     GURL fetch3_url = fetch3->full_url();
     GURL fetch4_url = fetch4->full_url();
     downloader.StartUpdateCheck(std::move(fetch1));
     downloader.StartUpdateCheck(std::move(fetch2));
@@ skipping 111 matching lines @@
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     std::unique_ptr<ManifestFetchData> fetch(
         CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true, 0);
     fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
-                        std::string());
+                        std::string(), false);
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(std::move(fetch));
     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(CreateManifestFetchData(kUpdateUrl));
     fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
-                        std::string());
+                        std::string(), false);
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(std::move(fetch));
     RunUntilIdle();
 
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     // The first fetch will fail, and require retrying.
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
@@ skipping 641 matching lines @@
                              nullptr,
                              service.GetDownloaderFactory());
     updater.Start();
     updater.EnsureDownloaderCreated();
 
     std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(update_url));
     const Extension* extension = tmp[0].get();
     fetch_data->AddExtension(extension->id(), extension->VersionString(),
                              &kNeverPingedData, kEmptyUpdateUrlData,
-                             std::string());
+                             std::string(), false);
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
 
     updater.downloader_->HandleManifestResults(fetch_data.get(), &results);
     Time last_ping_day =
         service.extension_prefs()->LastPingDay(extension->id());
     EXPECT_FALSE(last_ping_day.is_null());
     int64_t seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
   }
@@ skipping 92 matching lines @@
       }
     }
   }
 
  protected:
   std::unique_ptr<TestExtensionPrefs> prefs_;
 
   ManifestFetchData* CreateManifestFetchData(const GURL& update_url) {
     return new ManifestFetchData(update_url, 0, "",
                                  UpdateQueryParams::Get(UpdateQueryParams::CRX),
-                                 ManifestFetchData::PING);
+                                 ManifestFetchData::PING, false);
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
   ScopedTestingLocalState testing_local_state_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
@@ skipping 10 matching lines @@
 }
 
 TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
   TestExtensionUpdateCheckRequests(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestUpdateUrlData) {
   TestUpdateUrlDataEmpty();
   TestUpdateUrlDataSimple();
   TestUpdateUrlDataCompound();
-  TestUpdateUrlDataFromGallery(
-      extension_urls::GetWebstoreUpdateUrl().spec());
+  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
+                               false);
+  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
+                               true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestInstallSource) {
   TestInstallSource();
 }
 
 TEST_F(ExtensionUpdaterTest, TestDetermineUpdates) {
   TestDetermineUpdates();
 }
 
@@ skipping 187 matching lines @@
   MockExtensionDownloaderDelegate delegate;
   std::unique_ptr<ExtensionDownloader> downloader(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // First, verify that adding valid extensions does invoke the callbacks on
   // the delegate.
   std::string id = crx_file::id_util::GenerateId("foo");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(downloader->AddPendingExtension(
-      id, GURL("http://example.com/update"), false, 0));
+      id, GURL("http://example.com/update"), false, 0, false));
   downloader->StartAllPending(NULL);
   Mock::VerifyAndClearExpectations(&delegate);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with invalid update URLs should be rejected.
   id = crx_file::id_util::GenerateId("foo2");
   EXPECT_FALSE(downloader->AddPendingExtension(id, GURL("http:google.com:foo"),
-                                               false, 0));
+                                               false, 0, false));
   downloader->StartAllPending(NULL);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty IDs should be rejected.
   EXPECT_FALSE(
-      downloader->AddPendingExtension(std::string(), GURL(), false, 0));
+      downloader->AddPendingExtension(std::string(), GURL(), false, 0, false));
   downloader->StartAllPending(NULL);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // TODO(akalin): Test that extensions with empty update URLs
   // converted from user scripts are rejected.
 
   // Reset the ExtensionDownloader so that it drops the current fetcher.
   downloader.reset(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty update URLs should have a default one
   // filled in.
   id = crx_file::id_util::GenerateId("foo3");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
-  EXPECT_TRUE(downloader->AddPendingExtension(id, GURL(), false, 0));
+  EXPECT_TRUE(downloader->AddPendingExtension(id, GURL(), false, 0, false));
   downloader->StartAllPending(NULL);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
   ASSERT_TRUE(fetcher);
   EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 }
 
 TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
@@ skipping 103 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