[Extensions] Only add traffic management headers for webstore 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 "chrome/browser/extensions/updater/extension_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 793 matching lines @@
     fetch_data->AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c",
                              std::string(),
                              ManifestFetchData::FetchPriority::BACKGROUND);
     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 TestUpdateUrlDataFromUrl(
+      const std::string& update_url,
       ManifestFetchData::FetchPriority fetch_priority,
-      int num_extensions) {
+      int num_extensions,
+      bool should_include_traffic_management_headers) {
     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, num_extensions, &extensions, &url,
+    service.CreateTestExtensions(1, num_extensions, &extensions, &update_url,
                                  Manifest::INTERNAL);
 
     for (int i = 0; i < num_extensions; ++i) {
       const std::string& id = extensions[i]->id();
       EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
 
       downloader.AddExtension(*extensions[i], 0, fetch_priority);
     }
 
     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=");
+    const std::string& fetcher_url = fetcher->GetOriginalURL().spec();
+    std::string::size_type x = fetcher_url.find("x=");
     EXPECT_NE(std::string::npos, x);
-    std::string::size_type ap = update_url.find("ap%3D", x);
+    std::string::size_type ap = fetcher_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(
+    EXPECT_EQ(should_include_traffic_management_headers,
+              fetch_headers.HasHeader(
+                  ExtensionDownloader::kUpdateInteractivityHeader));
+    EXPECT_EQ(should_include_traffic_management_headers,
+              fetch_headers.HasHeader(ExtensionDownloader::kUpdateAppIdHeader));
+    EXPECT_EQ(
+        should_include_traffic_management_headers,
         fetch_headers.HasHeader(ExtensionDownloader::kUpdateUpdaterHeader));
 
-    std::string interactivity_value;
-    fetch_headers.GetHeader(ExtensionDownloader::kUpdateInteractivityHeader,
-                            &interactivity_value);
+    if (should_include_traffic_management_headers) {
+      std::string interactivity_value;
+      fetch_headers.GetHeader(ExtensionDownloader::kUpdateInteractivityHeader,
+                              &interactivity_value);
 
-    std::string expected_interactivity_value =
-        fetch_priority == ManifestFetchData::FetchPriority::FOREGROUND ? "fg"
-                                                                       : "bg";
-    EXPECT_EQ(expected_interactivity_value, interactivity_value);
+      std::string expected_interactivity_value =
+          fetch_priority == ManifestFetchData::FetchPriority::FOREGROUND ? "fg"
+                                                                         : "bg";
+      EXPECT_EQ(expected_interactivity_value, interactivity_value);
 
-    std::string appid_value;
-    fetch_headers.GetHeader(ExtensionDownloader::kUpdateAppIdHeader,
-                            &appid_value);
-    if (num_extensions > 1) {
-      for (int i = 0; i < num_extensions; ++i) {
-        EXPECT_TRUE(
-            testing::IsSubstring("", "", extensions[i]->id(), appid_value));
+      std::string appid_value;
+      fetch_headers.GetHeader(ExtensionDownloader::kUpdateAppIdHeader,
+                              &appid_value);
+      if (num_extensions > 1) {
+        for (int i = 0; i < num_extensions; ++i) {
+          EXPECT_TRUE(
+              testing::IsSubstring("", "", extensions[i]->id(), appid_value));
+        }
+      } else {
+        EXPECT_EQ(extensions[0]->id(), appid_value);
       }
-    } else {
-      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(

[Sorin Jianu, 2017/04/19 16:02:20]

this can be const.

[Devlin, 2017/04/19 17:59:24]

Done.

+          "%s-%s", UpdateQueryParams::GetProdIdString(UpdateQueryParams::CRX),
+          UpdateQueryParams::GetProdVersion().c_str());
+      EXPECT_EQ(expected_updater_value, updater_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")));
@@ skipping 1115 matching lines @@
 }
 
 TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
   TestExtensionUpdateCheckRequests(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestUpdateUrlData) {
   TestUpdateUrlDataEmpty();
   TestUpdateUrlDataSimple();
   TestUpdateUrlDataCompound();
-  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
-                               ManifestFetchData::FetchPriority::BACKGROUND, 1);
-  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
-                               ManifestFetchData::FetchPriority::FOREGROUND, 1);
-  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
-                               ManifestFetchData::FetchPriority::BACKGROUND, 2);
-  TestUpdateUrlDataFromGallery(extension_urls::GetWebstoreUpdateUrl().spec(),
-                               ManifestFetchData::FetchPriority::FOREGROUND, 4);
+  std::string gallery_url_spec = extension_urls::GetWebstoreUpdateUrl().spec();
+  TestUpdateUrlDataFromUrl(
+      gallery_url_spec, ManifestFetchData::FetchPriority::BACKGROUND, 1, true);
+  TestUpdateUrlDataFromUrl(
+      gallery_url_spec, ManifestFetchData::FetchPriority::FOREGROUND, 1, true);
+  TestUpdateUrlDataFromUrl(
+      gallery_url_spec, ManifestFetchData::FetchPriority::BACKGROUND, 2, true);
+  TestUpdateUrlDataFromUrl(
+      gallery_url_spec, ManifestFetchData::FetchPriority::FOREGROUND, 4, true);
+  TestUpdateUrlDataFromUrl("http://example.com/update",
+                           ManifestFetchData::FetchPriority::FOREGROUND, 4,
+                           false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestInstallSource) {
   TestInstallSource();
 }
 
 TEST_F(ExtensionUpdaterTest, TestDetermineUpdates) {
   TestDetermineUpdates();
 }
 
@@ skipping 381 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