Add support for Omaha cohorts to the component updater.

components/update_client/update_response.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_response.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 14 matching lines @@
 }
 UpdateResponse::~UpdateResponse() {
 }
 
 UpdateResponse::Results::Results() : daystart_elapsed_seconds(kNoDaystart) {
 }
 UpdateResponse::Results::Results(const Results& other) = default;
 UpdateResponse::Results::~Results() {
 }
 
-UpdateResponse::Result::Result() {
+UpdateResponse::Result::Result() {}
+UpdateResponse::Result::Result(const Result& other)
+    : crx_urls(other.crx_urls),
+      crx_diffurls(other.crx_diffurls),
+      manifest(other.manifest),
+      cohort(new std::string(*other.cohort)),
+      cohort_hint(new std::string(*other.cohort_hint)),
+      cohort_name(new std::string(*other.cohort_name)) {}
+UpdateResponse::Result& UpdateResponse::Result::operator=(const Result& other) {

[Sorin Jianu, 2016/08/22 19:59:34]

oh, no.

[waffles, 2016/08/22 23:40:32]

Yeah. :(

Tried another approach using a map.

+  crx_urls = other.crx_urls;
+  crx_diffurls = other.crx_diffurls;
+  manifest = other.manifest;
+  cohort = std::unique_ptr<std::string>(new std::string(*other.cohort));
+  cohort_name =
+      std::unique_ptr<std::string>(new std::string(*other.cohort_name));
+  cohort_hint =
+      std::unique_ptr<std::string>(new std::string(*other.cohort_hint));
+  return *this;
 }
-UpdateResponse::Result::Result(const Result& other) = default;
 UpdateResponse::Result::~Result() {
 }
 
 UpdateResponse::Result::Manifest::Manifest() {
 }
 UpdateResponse::Result::Manifest::Manifest(const Manifest& other) = default;
 UpdateResponse::Result::Manifest::~Manifest() {
 }
 
 UpdateResponse::Result::Manifest::Package::Package() : size(0), sizediff(0) {
@@ skipping 38 matching lines @@
   for (xmlAttr* attr = node->properties; attr != NULL; attr = attr->next) {
     if (!xmlStrcmp(attr->name, name) && attr->children &&
         attr->children->content) {
       return std::string(
           reinterpret_cast<const char*>(attr->children->content));
     }
   }
   return std::string();
 }
 
+// Returns the value of a named attribute, or nullptr .
+static std::unique_ptr<std::string> GetAttributePtr(
+    xmlNode* node,
+    const char* attribute_name) {
+  const xmlChar* name = reinterpret_cast<const xmlChar*>(attribute_name);
+  for (xmlAttr* attr = node->properties; attr != NULL; attr = attr->next) {
+    if (!xmlStrcmp(attr->name, name) && attr->children &&
+        attr->children->content) {
+      return std::unique_ptr<std::string>(new std::string(
+          reinterpret_cast<const char*>(attr->children->content)));
+    }
+  }
+  return nullptr;
+}
+
 // This is used for the xml parser to report errors. This assumes the context
 // is a pointer to a std::string where the error message should be appended.
 static void XmlErrorFunc(void* context, const char* message, ...) {
   va_list args;
   va_start(args, message);
   std::string* error = static_cast<std::string*>(context);
   base::StringAppendV(error, message, args);
   va_end(args);
 }
 
@@ skipping 155 matching lines @@
     return false;
   }
 
   return ParseManifestTag(manifests[0], result, error);
 }
 
 // Parses a single <app> tag.
 bool ParseAppTag(xmlNode* app,
                  UpdateResponse::Result* result,
                  std::string* error) {
+  // Read cohort information.
+  result->cohort = GetAttributePtr(app, "cohort");
+  result->cohort_hint = GetAttributePtr(app, "cohorthint");
+  result->cohort_name = GetAttributePtr(app, "cohortname");
+
   // Read the crx id.
   result->extension_id = GetAttribute(app, "appid");
   if (result->extension_id.empty()) {
     *error = "Missing appid on app node";
     return false;
   }
 
   // Get the <updatecheck> tag.
   std::vector<xmlNode*> updates = GetChildren(app, "updatecheck");
   if (updates.empty()) {
@@ skipping 71 matching lines @@
       results_.list.push_back(result);
     } else {
       ParseError("%s", error.c_str());
     }
   }
 
   return true;
 }
 
 }  // namespace update_client