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/lazy_instance.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/strings/string_util.h" 11 #include "base/strings/stringprintf.h" 12 #include "base/strings/utf_string_conversions.h" 13 #include "base/values.h" 14 #include "chrome/common/chrome_constants.h" 15 #include "chrome/common/url_constants.h" 16 #include "chrome/grit/generated_resources.h" 17 #include "extensions/common/error_utils.h" 18 #include "extensions/common/extension_urls.h" 19 #include "extensions/common/file_util.h" 20 #include "extensions/common/manifest.h" 21 #include "extensions/common/manifest_constants.h" 22 #include "extensions/common/manifest_handlers/permissions_parser.h" 23 #include "extensions/common/manifest_handlers/shared_module_info.h" 24 #include "extensions/common/permissions/api_permission.h" 25 #include "extensions/common/permissions/api_permission_set.h" 26 #include "ui/base/l10n/l10n_util.h" 27 28 #if defined(USE_AURA) 29 #include "ui/keyboard/keyboard_constants.h" 30 #endif 31 32 namespace extensions { 33 34 namespace keys = manifest_keys; 35 namespace errors = manifest_errors; 36 37 namespace { 38 39 const char kOverrideExtentUrlPatternFormat[] = "chrome://%s/*"; 40 41 const GURL& GetManifestURL(const Extension* extension, 42 const std::string& key) { 43 ManifestURL* manifest_url = 44 static_cast<ManifestURL*>(extension->GetManifestData(key)); 45 return manifest_url ? manifest_url->url_ : GURL::EmptyGURL(); 46 } 47 48 } // namespace 49 50 // static 51 const GURL& ManifestURL::GetDevToolsPage(const Extension* extension) { 52 return GetManifestURL(extension, keys::kDevToolsPage); 53 } 54 55 // static 56 const GURL ManifestURL::GetHomepageURL(const Extension* extension) { 57 const GURL& homepage_url = GetManifestURL(extension, keys::kHomepageURL); 58 if (homepage_url.is_valid()) 59 return homepage_url; 60 bool use_webstore_url = UpdatesFromGallery(extension) && 61 !SharedModuleInfo::IsSharedModule(extension); 62 return use_webstore_url 63 ? GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + 64 extension->id()) 65 : GURL::EmptyGURL(); 66 } 67 68 // static 69 bool ManifestURL::SpecifiedHomepageURL(const Extension* extension) { 70 return GetManifestURL(extension, keys::kHomepageURL).is_valid(); 71 } 72 73 // static 74 const GURL& ManifestURL::GetUpdateURL(const Extension* extension) { 75 return GetManifestURL(extension, keys::kUpdateURL); 76 } 77 78 // static 79 bool ManifestURL::UpdatesFromGallery(const Extension* extension) { 80 return extension_urls::IsWebstoreUpdateUrl(GetUpdateURL(extension)); 81 } 82 83 // static 84 bool ManifestURL::UpdatesFromGallery(const base::DictionaryValue* manifest) { 85 std::string url; 86 if (!manifest->GetString(keys::kUpdateURL, &url)) 87 return false; 88 return extension_urls::IsWebstoreUpdateUrl(GURL(url)); 89 } 90 91 // static 92 const GURL& ManifestURL::GetAboutPage(const Extension* extension) { 93 return GetManifestURL(extension, keys::kAboutPage); 94 } 95 96 // static 97 const GURL ManifestURL::GetDetailsURL(const Extension* extension) { 98 return extension->from_webstore() ? 99 GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + extension->id()) : 100 GURL::EmptyGURL(); 101 } 102 103 URLOverrides::URLOverrides() { 104 } 105 106 URLOverrides::~URLOverrides() { 107 } 108 109 static base::LazyInstance<URLOverrides::URLOverrideMap> g_empty_url_overrides = 110 LAZY_INSTANCE_INITIALIZER; 111 112 // static 113 const URLOverrides::URLOverrideMap& 114 URLOverrides::GetChromeURLOverrides(const Extension* extension) { 115 URLOverrides* url_overrides = static_cast<URLOverrides*>( 116 extension->GetManifestData(keys::kChromeURLOverrides)); 117 return url_overrides ? 118 url_overrides->chrome_url_overrides_ : 119 g_empty_url_overrides.Get(); 120 } 121 122 DevToolsPageHandler::DevToolsPageHandler() { 123 } 124 125 DevToolsPageHandler::~DevToolsPageHandler() { 126 } 127 128 bool DevToolsPageHandler::Parse(Extension* extension, base::string16* error) { 129 scoped_ptr<ManifestURL> manifest_url(new ManifestURL); 130 std::string devtools_str; 131 if (!extension->manifest()->GetString(keys::kDevToolsPage, &devtools_str)) { 132 *error = base::ASCIIToUTF16(errors::kInvalidDevToolsPage); 133 return false; 134 } 135 manifest_url->url_ = extension->GetResourceURL(devtools_str); 136 extension->SetManifestData(keys::kDevToolsPage, manifest_url.release()); 137 PermissionsParser::AddAPIPermission(extension, APIPermission::kDevtools); 138 return true; 139 } 140 141 const std::vector<std::string> DevToolsPageHandler::Keys() const { 142 return SingleKey(keys::kDevToolsPage); 143 } 144 145 HomepageURLHandler::HomepageURLHandler() { 146 } 147 148 HomepageURLHandler::~HomepageURLHandler() { 149 } 150 151 bool HomepageURLHandler::Parse(Extension* extension, base::string16* error) { 152 scoped_ptr<ManifestURL> manifest_url(new ManifestURL); 153 std::string homepage_url_str; 154 if (!extension->manifest()->GetString(keys::kHomepageURL, 155 &homepage_url_str)) { 156 *error = ErrorUtils::FormatErrorMessageUTF16(errors::kInvalidHomepageURL, 157 std::string()); 158 return false; 159 } 160 manifest_url->url_ = GURL(homepage_url_str); 161 if (!manifest_url->url_.is_valid() || 162 !manifest_url->url_.SchemeIsHTTPOrHTTPS()) { 163 *error = ErrorUtils::FormatErrorMessageUTF16( 164 errors::kInvalidHomepageURL, homepage_url_str); 165 return false; 166 } 167 extension->SetManifestData(keys::kHomepageURL, manifest_url.release()); 168 return true; 169 } 170 171 const std::vector<std::string> HomepageURLHandler::Keys() const { 172 return SingleKey(keys::kHomepageURL); 173 } 174 175 UpdateURLHandler::UpdateURLHandler() { 176 } 177 178 UpdateURLHandler::~UpdateURLHandler() { 179 } 180 181 bool UpdateURLHandler::Parse(Extension* extension, base::string16* error) { 182 scoped_ptr<ManifestURL> manifest_url(new ManifestURL); 183 std::string tmp_update_url; 184 185 if (!extension->manifest()->GetString(keys::kUpdateURL, &tmp_update_url)) { 186 *error = ErrorUtils::FormatErrorMessageUTF16(errors::kInvalidUpdateURL, 187 std::string()); 188 return false; 189 } 190 191 manifest_url->url_ = GURL(tmp_update_url); 192 if (!manifest_url->url_.is_valid() || 193 manifest_url->url_.has_ref()) { 194 *error = ErrorUtils::FormatErrorMessageUTF16( 195 errors::kInvalidUpdateURL, tmp_update_url); 196 return false; 197 } 198 199 extension->SetManifestData(keys::kUpdateURL, manifest_url.release()); 200 return true; 201 } 202 203 const std::vector<std::string> UpdateURLHandler::Keys() const { 204 return SingleKey(keys::kUpdateURL); 205 } 206 207 AboutPageHandler::AboutPageHandler() { 208 } 209 210 AboutPageHandler::~AboutPageHandler() { 211 } 212 213 bool AboutPageHandler::Parse(Extension* extension, base::string16* error) { 214 scoped_ptr<ManifestURL> manifest_url(new ManifestURL); 215 std::string about_str; 216 if (!extension->manifest()->GetString(keys::kAboutPage, &about_str)) { 217 *error = base::ASCIIToUTF16(errors::kInvalidAboutPage); 218 return false; 219 } 220 221 GURL absolute(about_str); 222 if (absolute.is_valid()) { 223 *error = base::ASCIIToUTF16(errors::kInvalidAboutPageExpectRelativePath); 224 return false; 225 } 226 manifest_url->url_ = extension->GetResourceURL(about_str); 227 if (!manifest_url->url_.is_valid()) { 228 *error = base::ASCIIToUTF16(errors::kInvalidAboutPage); 229 return false; 230 } 231 extension->SetManifestData(keys::kAboutPage, manifest_url.release()); 232 return true; 233 } 234 235 bool AboutPageHandler::Validate(const Extension* extension, 236 std::string* error, 237 std::vector<InstallWarning>* warnings) const { 238 // Validate path to the options page. 239 if (!extensions::ManifestURL::GetAboutPage(extension).is_empty()) { 240 const base::FilePath about_path = 241 extensions::file_util::ExtensionURLToRelativeFilePath( 242 extensions::ManifestURL::GetAboutPage(extension)); 243 const base::FilePath path = 244 extension->GetResource(about_path).GetFilePath(); 245 if (path.empty() || !base::PathExists(path)) { 246 *error = l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ABOUT_PAGE_FAILED, 247 about_path.LossyDisplayName()); 248 return false; 249 } 250 } 251 return true; 252 } 253 254 const std::vector<std::string> AboutPageHandler::Keys() const { 255 return SingleKey(keys::kAboutPage); 256 } 257 258 URLOverridesHandler::URLOverridesHandler() { 259 } 260 261 URLOverridesHandler::~URLOverridesHandler() { 262 } 263 264 bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) { 265 const base::DictionaryValue* overrides = NULL; 266 if (!extension->manifest()->GetDictionary(keys::kChromeURLOverrides, 267 &overrides)) { 268 *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides); 269 return false; 270 } 271 scoped_ptr<URLOverrides> url_overrides(new URLOverrides); 272 // Validate that the overrides are all strings 273 for (base::DictionaryValue::Iterator iter(*overrides); !iter.IsAtEnd(); 274 iter.Advance()) { 275 std::string page = iter.key(); 276 std::string val; 277 // Restrict override pages to a list of supported URLs. 278 bool is_override = (page != chrome::kChromeUINewTabHost && 279 page != chrome::kChromeUIBookmarksHost && 280 page != chrome::kChromeUIHistoryHost); 281 #if defined(OS_CHROMEOS) 282 is_override = (is_override && 283 page != chrome::kChromeUIActivationMessageHost); 284 #endif 285 #if defined(OS_CHROMEOS) 286 is_override = (is_override && page != keyboard::kKeyboardHost); 287 #endif 288 289 if (is_override || !iter.value().GetAsString(&val)) { 290 *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides); 291 return false; 292 } 293 // Replace the entry with a fully qualified chrome-extension:// URL. 294 url_overrides->chrome_url_overrides_[page] = extension->GetResourceURL(val); 295 296 // For component extensions, add override URL to extent patterns. 297 if (extension->is_legacy_packaged_app() && 298 extension->location() == Manifest::COMPONENT) { 299 URLPattern pattern(URLPattern::SCHEME_CHROMEUI); 300 std::string url = base::StringPrintf(kOverrideExtentUrlPatternFormat, 301 page.c_str()); 302 if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) { 303 *error = ErrorUtils::FormatErrorMessageUTF16( 304 errors::kInvalidURLPatternError, url); 305 return false; 306 } 307 extension->AddWebExtentPattern(pattern); 308 } 309 } 310 311 // An extension may override at most one page. 312 if (overrides->size() > 1) { 313 *error = base::ASCIIToUTF16(errors::kMultipleOverrides); 314 return false; 315 } 316 extension->SetManifestData(keys::kChromeURLOverrides, 317 url_overrides.release()); 318 return true; 319 } 320 321 const std::vector<std::string> URLOverridesHandler::Keys() const { 322 return SingleKey(keys::kChromeURLOverrides); 323 } 324 325 } // namespace extensions 326
