Move the parsing of 'update_url' & 'options_page' URLs out of Extension.

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 30 matching lines @@
 // static
 const GURL ManifestURL::GetHomepageURL(const Extension* extension) {
   const GURL& homepage_url = GetManifestURL(extension, keys::kHomepageURL);
   if (homepage_url.is_valid())
     return homepage_url;
   return extension->UpdatesFromGallery() ?
       GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + extension->id()) :
       GURL::EmptyGURL();
 }
 
+// static
+const GURL& ManifestURL::GetUpdateURL(const Extension* extension) {
+  return GetManifestURL(extension, keys::kUpdateURL);
+}
+
+// static
+const GURL& ManifestURL::GetOptionsPage(const Extension* extension) {
+  return GetManifestURL(extension, keys::kOptionsPage);
+}
+
 URLOverrides::URLOverrides() {
 }
 
 URLOverrides::~URLOverrides() {
 }
 
 static base::LazyInstance<URLOverrides::URLOverrideMap> g_empty_url_overrides =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
@@ skipping 47 matching lines @@
       (!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) {
+  scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
+  std::string tmp_update_url;
+
+  if (!value->GetAsString(&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) {
+  scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
+  std::string options_str;
+  if (!value->GetAsString(&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);
+      return false;
+    }
+    manifest_url->url_ = options_url;
+  } else {
+    GURL absolute(options_str);
+    if (absolute.is_valid()) {
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
+      return false;
+    }
+    manifest_url->url_ = extension->GetResourceURL(options_str);
+    if (!manifest_url->url_.is_valid()) {
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
+      return false;
+    }
+  }
+
+  extension->SetManifestData(keys::kOptionsPage, manifest_url.release());
+  return true;
+}
+
 URLOverridesHandler::URLOverridesHandler() {
 }
 
 URLOverridesHandler::~URLOverridesHandler() {
 }
 
 bool URLOverridesHandler::Parse(const base::Value* value,
                            Extension* extension,
                            string16* error) {
   const DictionaryValue* overrides = NULL;
@@ skipping 47 matching lines @@
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
   extension->SetManifestData(keys::kChromeURLOverrides,
                              url_overrides.release());
   return true;
 }
 
 }  // namespace extensions