chrome/common/extensions/manifest_url_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/common/extensions/manifest_url_handler.h"
   6
   7 #include "base/files/file_util.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "extensions/common/error_utils.h"
  14 #include "extensions/common/extension_urls.h"
  15 #include "extensions/common/file_util.h"
  16 #include "extensions/common/manifest.h"
  17 #include "extensions/common/manifest_constants.h"
  18 #include "extensions/common/manifest_handlers/shared_module_info.h"
  19 #include "extensions/strings/grit/extensions_strings.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21
  22 namespace extensions {
  23
  24 namespace keys = manifest_keys;
  25 namespace errors = manifest_errors;
  26
  27 // static
  28 const GURL& ManifestURL::Get(const Extension* extension,
  29                              const std::string& key) {
  30   ManifestURL* manifest_url =
  31       static_cast<ManifestURL*>(extension->GetManifestData(key));
  32   return manifest_url ? manifest_url->url_ : GURL::EmptyGURL();
  33 }
  34
  35 // static
  36 const GURL ManifestURL::GetHomepageURL(const Extension* extension) {
  37   const GURL& homepage_url = Get(extension, keys::kHomepageURL);
  38   if (homepage_url.is_valid())
  39     return homepage_url;
  40   bool use_webstore_url = UpdatesFromGallery(extension) &&
  41                           !SharedModuleInfo::IsSharedModule(extension);
  42   return use_webstore_url
  43              ? GURL(extension_urls::GetWebstoreItemDetailURLPrefix() +
  44                     extension->id())
  45              : GURL::EmptyGURL();
  46 }
  47
  48 // static
  49 bool ManifestURL::SpecifiedHomepageURL(const Extension* extension) {
  50   return Get(extension, keys::kHomepageURL).is_valid();
  51 }
  52
  53 // static
  54 const GURL& ManifestURL::GetUpdateURL(const Extension* extension) {
  55   return Get(extension, keys::kUpdateURL);
  56 }
  57
  58 // static
  59 bool ManifestURL::UpdatesFromGallery(const Extension* extension) {
  60   return extension_urls::IsWebstoreUpdateUrl(GetUpdateURL(extension));
  61 }
  62
  63 // static
  64 bool  ManifestURL::UpdatesFromGallery(const base::DictionaryValue* manifest) {
  65   std::string url;
  66   if (!manifest->GetString(keys::kUpdateURL, &url))
  67     return false;
  68   return extension_urls::IsWebstoreUpdateUrl(GURL(url));
  69 }
  70
  71 // static
  72 const GURL& ManifestURL::GetAboutPage(const Extension* extension) {
  73   return Get(extension, keys::kAboutPage);
  74 }
  75
  76 // static
  77 const GURL ManifestURL::GetDetailsURL(const Extension* extension) {
  78   return extension->from_webstore() ?
  79       GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + extension->id()) :
  80       GURL::EmptyGURL();
  81 }
  82
  83 HomepageURLHandler::HomepageURLHandler() {
  84 }
  85
  86 HomepageURLHandler::~HomepageURLHandler() {
  87 }
  88
  89 bool HomepageURLHandler::Parse(Extension* extension, base::string16* error) {
  90   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
  91   std::string homepage_url_str;
  92   if (!extension->manifest()->GetString(keys::kHomepageURL,
  93                                         &homepage_url_str)) {
  94     *error = ErrorUtils::FormatErrorMessageUTF16(errors::kInvalidHomepageURL,
  95                                                  std::string());
  96     return false;
  97   }
  98   manifest_url->url_ = GURL(homepage_url_str);
  99   if (!manifest_url->url_.is_valid() ||
 100       !manifest_url->url_.SchemeIsHTTPOrHTTPS()) {
 101     *error = ErrorUtils::FormatErrorMessageUTF16(
 102         errors::kInvalidHomepageURL, homepage_url_str);
 103     return false;
 104   }
 105   extension->SetManifestData(keys::kHomepageURL, manifest_url.release());
 106   return true;
 107 }
 108
 109 const std::vector<std::string> HomepageURLHandler::Keys() const {
 110   return SingleKey(keys::kHomepageURL);
 111 }
 112
 113 UpdateURLHandler::UpdateURLHandler() {
 114 }
 115
 116 UpdateURLHandler::~UpdateURLHandler() {
 117 }
 118
 119 bool UpdateURLHandler::Parse(Extension* extension, base::string16* error) {
 120   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
 121   std::string tmp_update_url;
 122
 123   if (!extension->manifest()->GetString(keys::kUpdateURL, &tmp_update_url)) {
 124     *error = ErrorUtils::FormatErrorMessageUTF16(errors::kInvalidUpdateURL,
 125                                                  std::string());
 126     return false;
 127   }
 128
 129   manifest_url->url_ = GURL(tmp_update_url);
 130   if (!manifest_url->url_.is_valid() ||
 131       manifest_url->url_.has_ref()) {
 132     *error = ErrorUtils::FormatErrorMessageUTF16(
 133         errors::kInvalidUpdateURL, tmp_update_url);
 134     return false;
 135   }
 136
 137   extension->SetManifestData(keys::kUpdateURL, manifest_url.release());
 138   return true;
 139 }
 140
 141 const std::vector<std::string> UpdateURLHandler::Keys() const {
 142   return SingleKey(keys::kUpdateURL);
 143 }
 144
 145 AboutPageHandler::AboutPageHandler() {
 146 }
 147
 148 AboutPageHandler::~AboutPageHandler() {
 149 }
 150
 151 bool AboutPageHandler::Parse(Extension* extension, base::string16* error) {
 152   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
 153   std::string about_str;
 154   if (!extension->manifest()->GetString(keys::kAboutPage, &about_str)) {
 155     *error = base::ASCIIToUTF16(errors::kInvalidAboutPage);
 156     return false;
 157   }
 158
 159   GURL absolute(about_str);
 160   if (absolute.is_valid()) {
 161     *error = base::ASCIIToUTF16(errors::kInvalidAboutPageExpectRelativePath);
 162     return false;
 163   }
 164   manifest_url->url_ = extension->GetResourceURL(about_str);
 165   if (!manifest_url->url_.is_valid()) {
 166     *error = base::ASCIIToUTF16(errors::kInvalidAboutPage);
 167     return false;
 168   }
 169   extension->SetManifestData(keys::kAboutPage, manifest_url.release());
 170   return true;
 171 }
 172
 173 bool AboutPageHandler::Validate(const Extension* extension,
 174                                 std::string* error,
 175                                 std::vector<InstallWarning>* warnings) const {
 176   // Validate path to the options page.
 177   if (!extensions::ManifestURL::GetAboutPage(extension).is_empty()) {
 178     const base::FilePath about_path =
 179         extensions::file_util::ExtensionURLToRelativeFilePath(
 180             extensions::ManifestURL::GetAboutPage(extension));
 181     const base::FilePath path =
 182         extension->GetResource(about_path).GetFilePath();
 183     if (path.empty() || !base::PathExists(path)) {
 184       *error = l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ABOUT_PAGE_FAILED,
 185                                          about_path.LossyDisplayName());
 186       return false;
 187     }
 188   }
 189   return true;
 190 }
 191
 192 const std::vector<std::string> AboutPageHandler::Keys() const {
 193   return SingleKey(keys::kAboutPage);
 194 }
 195
 196 }  // namespace extensions