Allow extensions of the ManifestParser outside of the content/ layer.

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 "content/public/renderer/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"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/manifest.h"
+#include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/manifest/manifest_uma_util.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 namespace {
 
 // Helper function that returns whether the given |str| is a valid width or
 // height value for an icon sizes per:
 // https://html.spec.whatwg.org/multipage/semantics.html#attr-link-sizes
@@ skipping 53 matching lines @@
 }
 
 const std::string& GetErrorPrefix() {
   CR_DEFINE_STATIC_LOCAL(std::string, error_prefix,
                          ("Manifest parsing error: "));
   return error_prefix;
 }
 
 }  // anonymous namespace
 
+// static
+scoped_ptr<ManifestParser> ManifestParser::Get() {
+  ManifestParser* parser = nullptr;
+  if (GetContentClient()->renderer()->OverrideManifestParser(&parser)) {
+    return scoped_ptr<ManifestParser>(parser);
+  }
 
-ManifestParser::ManifestParser(const base::StringPiece& data,
-                               const GURL& manifest_url,
-                               const GURL& document_url)
-    : data_(data),
-      manifest_url_(manifest_url),
-      document_url_(document_url),
-      failed_(false) {
+  return scoped_ptr<ManifestParser>(new ManifestParser);
+}
+
+ManifestParser::ManifestParser()
+    : failed_(false) {
 }
 
 ManifestParser::~ManifestParser() {
 }
 
-void ManifestParser::Parse() {
+void ManifestParser::Parse(const base::StringPiece& data,
+                           const GURL& manifest_url,
+                           const GURL& document_url) {
+  manifest_url_ = manifest_url;
+  document_url_ = document_url;
+
+  DCHECK(manifest_url_.is_valid());
+  DCHECK(document_url_.is_valid());
+
   std::string parse_error;
   scoped_ptr<base::Value> value(
-      base::JSONReader::ReadAndReturnError(data_, base::JSON_PARSE_RFC,
+      base::JSONReader::ReadAndReturnError(data, base::JSON_PARSE_RFC,
                                            nullptr, &parse_error));
 
   if (!value) {
     errors_.push_back(GetErrorPrefix() + parse_error);
     ManifestUmaUtil::ParseFailed();
     failed_ = true;
     return;
   }
 
   base::DictionaryValue* dictionary = nullptr;
   if (!value->GetAsDictionary(&dictionary)) {
     errors_.push_back(GetErrorPrefix() +
                       "root element must be a valid JSON object.");
     ManifestUmaUtil::ParseFailed();
     failed_ = true;
     return;
   }
   DCHECK(dictionary);
 
+  ParseExtensionPoint(*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_);
 }
 
+void ManifestParser::ParseExtensionPoint(const base::DictionaryValue&) {
+}
+
 const Manifest& ManifestParser::manifest() const {
   return manifest_;
 }
 
 const std::vector<std::string>& ManifestParser::errors() const {
   return errors_;
 }
 
 bool ManifestParser::failed() const {
   return failed_;
@@ skipping 181 matching lines @@
     icon.type = ParseIconType(*icon_dictionary);
     icon.density = ParseIconDensity(*icon_dictionary);
     icon.sizes = ParseIconSizes(*icon_dictionary);
 
     icons.push_back(icon);
   }
 
   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