Parse "purpose" member from Web Manifest

content/renderer/manifest/manifest_parser.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 "content/renderer/manifest/manifest_parser.h"
 
 #include <stddef.h>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
@@ skipping 258 matching lines @@
       blink::WebIconSizesParser::parseIconSizes(sizes_str.string());
   sizes.resize(web_sizes.size());
   for (size_t i = 0; i < web_sizes.size(); ++i)
     sizes[i] = web_sizes[i];
   if (sizes.empty()) {
     AddErrorInfo("found icon with no valid size.");
   }
   return sizes;
 }
 
+std::vector<Manifest::Icon::IconPurpose> ManifestParser::ParseIconPurpose(
+    const base::DictionaryValue& icon) {
+  base::NullableString16 purpose_str = ParseString(icon, "purpose", NoTrim);
+  std::vector<Manifest::Icon::IconPurpose> purposes;
+
+  if (purpose_str.is_null()) {
+    purposes.push_back(Manifest::Icon::IconPurpose::ANY);
+    return purposes;
+  }
+
+  std::vector<base::string16> keywords = base::SplitString(
+      purpose_str.string(), base::ASCIIToUTF16(" "),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  for (const base::string16& keyword : keywords) {
+    if (base::LowerCaseEqualsASCII(keyword, "any")) {
+      purposes.push_back(Manifest::Icon::IconPurpose::ANY);
+    } else if (base::LowerCaseEqualsASCII(keyword, "badge")) {
+      purposes.push_back(Manifest::Icon::IconPurpose::BADGE);
+    } else {
+      AddErrorInfo(
+          "found icon with invalid purpose. "
+          "Using default value 'any'.");
+    }
+  }
+
+  if (purposes.empty()) {
+    purposes.push_back(Manifest::Icon::IconPurpose::ANY);
+  }
+
+  return purposes;
+}
+
 std::vector<Manifest::Icon> ManifestParser::ParseIcons(
     const base::DictionaryValue& dictionary) {
   std::vector<Manifest::Icon> icons;
   if (!dictionary.HasKey("icons"))
     return icons;
 
   const base::ListValue* icons_list = nullptr;
   if (!dictionary.GetList("icons", &icons_list)) {
     AddErrorInfo("property 'icons' ignored, type array expected.");
     return icons;
   }
 
   for (size_t i = 0; i < icons_list->GetSize(); ++i) {
     const base::DictionaryValue* icon_dictionary = nullptr;
     if (!icons_list->GetDictionary(i, &icon_dictionary))
       continue;
 
     Manifest::Icon icon;
     icon.src = ParseIconSrc(*icon_dictionary);
     // An icon MUST have a valid src. If it does not, it MUST be ignored.
     if (!icon.src.is_valid())
       continue;
     icon.type = ParseIconType(*icon_dictionary);
     icon.sizes = ParseIconSizes(*icon_dictionary);
+    icon.purpose = ParseIconPurpose(*icon_dictionary);
 
     icons.push_back(icon);
   }
 
   return icons;
 }
 
 base::NullableString16 ManifestParser::ParseRelatedApplicationPlatform(
     const base::DictionaryValue& application) {
   return ParseString(application, "platform", Trim);
@@ skipping 75 matching lines @@
 }
 
 void ManifestParser::AddErrorInfo(const std::string& error_msg,
                                   bool critical,
                                   int error_line,
                                   int error_column) {
   errors_.push_back({error_msg, critical, error_line, error_column});
 }
 
 } // namespace content