Manifest handler for all keys background-related.

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"
@@ skipping 85 matching lines @@
   std::string 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;
 }
 
+const std::vector<std::string> DevToolsPageHandler::Keys() const {
+  return SingleKey(keys::kDevToolsPage);
+}
+
 HomepageURLHandler::HomepageURLHandler() {
 }
 
 HomepageURLHandler::~HomepageURLHandler() {
 }
 
 bool HomepageURLHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string 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;
 }
 
+const std::vector<std::string> HomepageURLHandler::Keys() const {
+  return SingleKey(keys::kHomepageURL);
+}
+
 UpdateURLHandler::UpdateURLHandler() {
 }
 
 UpdateURLHandler::~UpdateURLHandler() {
 }
 
 bool UpdateURLHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string 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;
 }
 
+const std::vector<std::string> UpdateURLHandler::Keys() const {
+  return SingleKey(keys::kUpdateURL);
+}
+
 OptionsPageHandler::OptionsPageHandler() {
 }
 
 OptionsPageHandler::~OptionsPageHandler() {
 }
 
 bool OptionsPageHandler::Parse(Extension* extension, string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string options_str;
   if (!extension->manifest()->GetString(keys::kOptionsPage, &options_str)) {
@@ skipping 20 matching lines @@
     if (!manifest_url->url_.is_valid()) {
       *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
       return false;
     }
   }
 
   extension->SetManifestData(keys::kOptionsPage, manifest_url.release());
   return true;
 }
 
+const std::vector<std::string> OptionsPageHandler::Keys() const {
+  return SingleKey(keys::kOptionsPage);
+}
+
 URLOverridesHandler::URLOverridesHandler() {
 }
 
 URLOverridesHandler::~URLOverridesHandler() {
 }
 
 bool URLOverridesHandler::Parse(Extension* extension, string16* error) {
   const DictionaryValue* overrides = NULL;
   if (!extension->manifest()->GetDictionary(keys::kChromeURLOverrides,
                                             &overrides)) {
@@ skipping 45 matching lines @@
   // An extension may override at most one page.
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
   extension->SetManifestData(keys::kChromeURLOverrides,
                              url_overrides.release());
   return true;
 }
 
+const std::vector<std::string> URLOverridesHandler::Keys() const {
+  return SingleKey(keys::kChromeURLOverrides);
+}
+
 }  // namespace extensions