Change manifest handler interface to always (implicitly) pass the entire manifest to handlers.

chrome/common/extensions/manifest_url_handler.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/manifest_url_handler.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
 
 namespace keys = extension_manifest_keys;
 namespace errors = extension_manifest_errors;
 
 namespace extensions {
 
 namespace {
 
@@ skipping 58 matching lines @@
          url_overrides->chrome_url_overrides_ :
          g_empty_url_overrides.Get();
 }
 
 DevToolsPageHandler::DevToolsPageHandler() {
 }
 
 DevToolsPageHandler::~DevToolsPageHandler() {
 }
 
-bool DevToolsPageHandler::Parse(const base::Value* value,
-                                Extension* extension,
-                                string16* error) {
+bool DevToolsPageHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string devtools_str;
-  if (!value->GetAsString(&devtools_str)) {
+  if (!extension->manifest()->GetString(keys::kDevToolsPage, &devtools_str)) {
     *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
     return false;
   }
   manifest_url->url_ = extension->GetResourceURL(devtools_str);
   extension->SetManifestData(keys::kDevToolsPage, manifest_url.release());
   return true;
 }
 
 HomepageURLHandler::HomepageURLHandler() {
 }
 
 HomepageURLHandler::~HomepageURLHandler() {
 }
 
-bool HomepageURLHandler::Parse(const base::Value* value,
-                               Extension* extension,
-                               string16* error) {
+bool HomepageURLHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string homepage_url_str;
-  if (!value->GetAsString(&homepage_url_str)) {
+  if (!extension->manifest()->GetString(keys::kHomepageURL,
+                                        &homepage_url_str)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidHomepageURL, "");
     return false;
   }
   manifest_url->url_ = GURL(homepage_url_str);
   if (!manifest_url->url_.is_valid() ||
       (!manifest_url->url_.SchemeIs("http") &&
        !manifest_url->url_.SchemeIs("https"))) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidHomepageURL, homepage_url_str);
     return false;
   }
   extension->SetManifestData(keys::kHomepageURL, manifest_url.release());
   return true;
 }
 
 UpdateURLHandler::UpdateURLHandler() {
 }
 
 UpdateURLHandler::~UpdateURLHandler() {
 }
 
-bool UpdateURLHandler::Parse(const base::Value* value,
-                             Extension* extension,
-                             string16* error) {
+bool UpdateURLHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string tmp_update_url;
 
-  if (!value->GetAsString(&tmp_update_url)) {
+  if (!extension->manifest()->GetString(keys::kUpdateURL, &tmp_update_url)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidUpdateURL, "");
     return false;
   }
 
   manifest_url->url_ = GURL(tmp_update_url);
   if (!manifest_url->url_.is_valid() ||
       manifest_url->url_.has_ref()) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidUpdateURL, tmp_update_url);
     return false;
   }
 
   extension->SetManifestData(keys::kUpdateURL, manifest_url.release());
   return true;
 }
 
 OptionsPageHandler::OptionsPageHandler() {
 }
 
 OptionsPageHandler::~OptionsPageHandler() {
 }
 
-bool OptionsPageHandler::Parse(const base::Value* value,
-                               Extension* extension,
-                               string16* error) {
+bool OptionsPageHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string options_str;
-  if (!value->GetAsString(&options_str)) {
+  if (!extension->manifest()->GetString(keys::kOptionsPage, &options_str)) {
     *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
     return false;
   }
 
   if (extension->is_hosted_app()) {
     // hosted apps require an absolute URL.
     GURL options_url(options_str);
     if (!options_url.is_valid() ||
         !(options_url.SchemeIs("http") || options_url.SchemeIs("https"))) {
       *error = ASCIIToUTF16(errors::kInvalidOptionsPageInHostedApp);
@@ skipping 16 matching lines @@
   extension->SetManifestData(keys::kOptionsPage, manifest_url.release());
   return true;
 }
 
 URLOverridesHandler::URLOverridesHandler() {
 }
 
 URLOverridesHandler::~URLOverridesHandler() {
 }
 
-bool URLOverridesHandler::Parse(const base::Value* value,
-                           Extension* extension,
-                           string16* error) {
+bool URLOverridesHandler::Parse(Extension* extension, string16* error) {
   const DictionaryValue* overrides = NULL;
-  if (!value->GetAsDictionary(&overrides)) {
+  if (!extension->manifest()->GetDictionary(keys::kChromeURLOverrides,
+                                            &overrides)) {
     *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
     return false;
   }
   scoped_ptr<URLOverrides> url_overrides(new URLOverrides);
   // Validate that the overrides are all strings
   for (DictionaryValue::key_iterator iter = overrides->begin_keys();
        iter != overrides->end_keys(); ++iter) {
     std::string page = *iter;
     std::string val;
     // Restrict override pages to a list of supported URLs.
@@ skipping 36 matching lines @@
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
   extension->SetManifestData(keys::kChromeURLOverrides,
                              url_overrides.release());
   return true;
 }
 
 }  // namespace extensions