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>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/version.h"
 #include "libxml/tree.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace update_client {
 
 static const char* kExpectedResponseProtocol = "3.0";
+const char* UpdateResponse::Result::kCohort = "cohort";
+const char* UpdateResponse::Result::kCohortHint = "cohorthint";
+const char* UpdateResponse::Result::kCohortName = "cohortname";
 
 UpdateResponse::UpdateResponse() {
 }
 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) = default;
 UpdateResponse::Result::~Result() {
 }
 
 UpdateResponse::Result::Manifest::Manifest() {
 }
 UpdateResponse::Result::Manifest::Manifest(const Manifest& other) = default;
 UpdateResponse::Result::Manifest::~Manifest() {
 }
 
@@ skipping 39 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(

[Sorin Jianu, 2016/08/23 00:20:03]

Can we use MakeUnique or WrapUniquento make this somehow more readable?

[waffles, 2016/08/23 00:36:18]

Done.

+          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.
+  auto cohort = GetAttributePtr(app, "cohort");
+  static const char* attrs[] = {UpdateResponse::Result::kCohort,
+                                UpdateResponse::Result::kCohortHint,
+                                UpdateResponse::Result::kCohortName};
+  for (const auto& attr : attrs) {
+    auto value = GetAttributePtr(app, attr);
+    if (value)
+      result->cohort_attrs.insert({attr, *value});
+  }
+
   // 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