Allow component installers to specify a map of installer attributes.

components/update_client/update_checker.cc

 // Copyright 2014 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 "components/update_client/update_checker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/persisted_data.h"
 #include "components/update_client/request_sender.h"
+#include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 namespace update_client {
 
 namespace {
 
 // Returns a sanitized version of the brand or an empty string otherwise.
 std::string SanitizeBrand(const std::string& brand) {
   return IsValidBrand(brand) ? brand : std::string("");
 }
 
-// Returns a sanitized version of the |ap| or an empty string otherwise.
-std::string SanitizeAp(const std::string& ap) {
-  return IsValidAp(ap) ? ap : std::string();
+// Filters invalid attributes from |installer_attributes|.
+update_client::InstallerAttributes SanitizeInstallerAttributes(
+    const update_client::InstallerAttributes& installer_attributes) {
+  update_client::InstallerAttributes sanitized_attrs;
+  for (const auto& attr : installer_attributes) {
+    if (IsValidInstallerAttribute(attr))
+      sanitized_attrs.insert(attr);
+  }
+  return sanitized_attrs;
 }
 
 // Returns true if at least one item requires network encryption.
 bool IsEncryptionRequired(const std::vector<CrxUpdateItem*>& items) {
   for (const auto& item : items) {
     if (item->component.requires_network_encryption)
       return true;
   }
   return false;
 }
@@ skipping 13 matching lines @@
 //      </packages>
 //    </app>
 std::string BuildUpdateCheckRequest(const Configurator& config,
                                     const std::vector<CrxUpdateItem*>& items,
                                     PersistedData* metadata,
                                     const std::string& additional_attributes) {
   const std::string brand(SanitizeBrand(config.GetBrand()));
   std::string app_elements;
   for (size_t i = 0; i != items.size(); ++i) {
     const CrxUpdateItem* item = items[i];
-    const std::string ap(SanitizeAp(item->component.ap));
+    const update_client::InstallerAttributes installer_attributes(
+        SanitizeInstallerAttributes(item->component.installer_attributes));
     std::string app("<app ");
     base::StringAppendF(&app, "appid=\"%s\" version=\"%s\"", item->id.c_str(),
                         item->component.version.GetString().c_str());
     if (!brand.empty())
       base::StringAppendF(&app, " brand=\"%s\"", brand.c_str());
     if (item->on_demand)
       base::StringAppendF(&app, " installsource=\"ondemand\"");
-    if (!ap.empty())
-      base::StringAppendF(&app, " ap=\"%s\"", ap.c_str());
+
+    for (const auto& attr : installer_attributes)
+      base::StringAppendF(&app, " %s=\"%s\"", attr.first.c_str(),
+                          attr.second.c_str());
+
     base::StringAppendF(&app, ">");
     base::StringAppendF(&app, "<updatecheck />");
     base::StringAppendF(&app, "<ping rd=\"%d\" ping_freshness=\"%s\" />",
                         metadata->GetDateLastRollCall(item->id),
                         metadata->GetPingFreshness(item->id).c_str());
     if (!item->component.fingerprint.empty()) {
       base::StringAppendF(&app,
                           "<packages>"
                           "<package fp=\"%s\"/>"
                           "</packages>",
@@ skipping 108 matching lines @@
 }  // namespace
 
 std::unique_ptr<UpdateChecker> UpdateChecker::Create(
     const scoped_refptr<Configurator>& config,
     PersistedData* persistent) {
   return std::unique_ptr<UpdateChecker>(
       new UpdateCheckerImpl(config, persistent));
 }
 
 }  // namespace update_client