Push registration should read a "gcm_user_visible_only" key from the 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 "base/json/json_reader.h"
 #include "base/strings/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 110 matching lines @@
   }
   DCHECK(dictionary);
 
   manifest_.name = ParseName(*dictionary);
   manifest_.short_name = ParseShortName(*dictionary);
   manifest_.start_url = ParseStartURL(*dictionary);
   manifest_.display = ParseDisplay(*dictionary);
   manifest_.orientation = ParseOrientation(*dictionary);
   manifest_.icons = ParseIcons(*dictionary);
   manifest_.gcm_sender_id = ParseGCMSenderID(*dictionary);
+  manifest_.gcm_user_visible_only = ParseGCMUserVisibleOnly(*dictionary);
 
   ManifestUmaUtil::ParseSucceeded(manifest_);
 }
 
 const Manifest& ManifestParser::manifest() const {
   return manifest_;
 }
 
 const std::vector<std::string>& ManifestParser::errors() const {
   return errors_;
@@ skipping 15 matching lines @@
     errors_.push_back(GetErrorPrefix() +
                       "property '" + key + "' ignored, type string expected.");
     return base::NullableString16();
   }
 
   if (trim == Trim)
     base::TrimWhitespace(value, base::TRIM_ALL, &value);
   return base::NullableString16(value, false);
 }
 
+bool ManifestParser::ParseBoolean(const base::DictionaryValue& dictionary,

[mlamouri (slow - plz ping), 2014/12/01 21:05:09]

Could you get ::ParseBoolean() on top, around ParseString() and ParseURL()? 
(Ideally: boolean / string / url)

[Peter Beverloo, 2014/12/03 15:01:59]

Done.

+                                  const std::string& key,
+                                  bool default_value) {
+  if (!dictionary.HasKey(key))
+    return default_value;
+
+  bool value;
+  if (!dictionary.GetBoolean(key, &value)) {
+    errors_.push_back(GetErrorPrefix() +
+                      "property '" + key + "' ignored, type boolean expected.");
+    return default_value;
+  }
+
+  return value;
+}
+
 GURL ManifestParser::ParseURL(const base::DictionaryValue& dictionary,
                               const std::string& key,
                               const GURL& base_url) {
   base::NullableString16 url_str = ParseString(dictionary, key, NoTrim);
   if (url_str.is_null())
     return GURL();
 
   return base_url.Resolve(url_str.string());
 }
 
@@ skipping 139 matching lines @@
   }
 
   return icons;
 }
 
 base::NullableString16 ManifestParser::ParseGCMSenderID(
     const base::DictionaryValue& dictionary)  {
   return ParseString(dictionary, "gcm_sender_id", Trim);
 }
 
+bool ManifestParser::ParseGCMUserVisibleOnly(
+    const base::DictionaryValue& dictionary) {
+  return ParseBoolean(dictionary, "gcm_user_visible_only", false);
+}
+
 } // namespace content