Move [Homepage,Options,Update,DevTools]URL out of Extension

chrome/common/extensions/api/extension_urls/extension_urls_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/api/extension_urls/extension_urls_handler.h"
+
+#include "base/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "extensions/common/error_utils.h"
+
+namespace extensions {
+
+namespace {
+
+namespace errors = extension_manifest_errors;
+namespace keys = extension_manifest_keys;
+
+const GURL& GetExtensionURL(const Extension* extension,
+                            const std::string& key) {
+  ExtensionURL* extension_url = static_cast<ExtensionURL*>(
+      extension->GetManifestData(key));
+  return extension_url ? extension_url->url : GURL::EmptyGURL();
+}
+
+}  // namespace
+
+ExtensionURL::ExtensionURL(const GURL& extension_url) : url(extension_url) {
+}
+
+ExtensionURL::~ExtensionURL() {
+}
+
+// static
+const GURL& ExtensionURL::GetDevToolsURL(const Extension* extension) {
+  return GetExtensionURL(extension, keys::kDevToolsPage);
+}
+
+// static
+// Not const GURL& because if we have an invalid homepage_url, we try to
+// construct one, and we cannot return a reference to a temporary.
+GURL ExtensionURL::GetHomepageURL(const Extension* extension) {
+  const GURL& homepage_url = GetExtensionURL(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& ExtensionURL::GetOptionsURL(const Extension* extension) {
+  return GetExtensionURL(extension, keys::kOptionsPage);
+}
+
+// static
+const GURL& ExtensionURL::GetUpdateURL(const Extension* extension) {
+  return GetExtensionURL(extension, keys::kUpdateURL);
+}
+
+DevToolsPageHandler::DevToolsPageHandler() {
+}
+
+DevToolsPageHandler::~DevToolsPageHandler() {
+}
+
+bool DevToolsPageHandler::Parse(const base::Value* value,
+                                Extension* extension,
+                                string16* error) {
+  std::string devtools_str;
+  if (!value->GetAsString(&devtools_str)) {
+    *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
+    return false;
+  }
+
+  extension->SetManifestData(
+      keys::kDevToolsPage,
+      new ExtensionURL(extension->GetResourceURL(devtools_str)));
+  return true;
+}
+
+HomepageURLHandler::HomepageURLHandler() {
+}
+
+HomepageURLHandler::~HomepageURLHandler() {
+}
+
+bool HomepageURLHandler::Parse(const base::Value* value,
+                               Extension* extension,
+                               string16* error) {
+  std::string homepage_str;
+  if (!value->GetAsString(&homepage_str)) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidHomepageURL, "");
+    return false;
+  }
+  GURL homepage_url(homepage_str);
+  if (!homepage_url.is_valid() ||
+      (!homepage_url.SchemeIs("http") && !homepage_url.SchemeIs("https"))) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidHomepageURL, homepage_str);
+    return false;
+  }
+
+  extension->SetManifestData(keys::kHomepageURL,
+                             new ExtensionURL(homepage_url));
+  return true;
+}
+
+OptionsPageHandler::OptionsPageHandler() {
+}
+
+OptionsPageHandler::~OptionsPageHandler() {
+}
+
+bool OptionsPageHandler::Parse(const base::Value* value,
+                               Extension* extension,
+                               string16* error) {
+  std::string options_str;
+  if (!value->GetAsString(&options_str)) {
+    *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
+    return false;
+  }
+
+  GURL options_url;
+  if (extension->is_hosted_app()) {
+    // hosted apps require an absolute URL.
+    options_url = GURL(options_str);
+    if (!options_url.is_valid() ||
+        !(options_url.SchemeIs("http") || options_url.SchemeIs("https"))) {
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPageInHostedApp);
+      return false;
+    }
+  } else {
+    options_url = GURL(options_str);
+    if (options_url.is_valid()) {
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
+      return false;
+    }
+    options_url = extension->GetResourceURL(options_str);
+    if (!options_url.is_valid()) {
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
+      return false;
+    }
+  }
+
+  extension->SetManifestData(keys::kOptionsPage, new ExtensionURL(options_url));
+  return true;
+}
+
+UpdateURLHandler::UpdateURLHandler() {
+}
+
+UpdateURLHandler::~UpdateURLHandler() {
+}
+
+bool UpdateURLHandler::Parse(const base::Value* value,
+                             Extension* extension,
+                             string16* error) {
+  std::string update_str;
+  if (!value->GetAsString(&update_str)) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidUpdateURL, "");
+    return false;
+  }
+  GURL update_url = GURL(update_str);
+  if (!update_url.is_valid() || update_url.has_ref()) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidUpdateURL, update_str);
+    return false;
+  }
+
+  extension->SetManifestData(keys::kUpdateURL, new ExtensionURL(update_url));
+  return true;
+}
+
+}  // namespace extensions