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

chrome/common/extensions/extension.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/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
-// TODO(rdevlin.cronin): Remove this once PageAction, BrowserAction, and
-// SystemIndicator have been moved out of Extension.
+// TODO(rdevlin.cronin): Remove these once all accessors have been moved out of
+// the core Extension class.
 #include "chrome/common/extensions/api/extension_action/action_handler_helpers.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
+#include "chrome/common/extensions/api/extension_urls/extension_urls_handler.h"
 #include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
@@ skipping 400 matching lines @@
 
 void Extension::GetBasicInfo(bool enabled,
                              DictionaryValue* info) const {
   info->SetString(info_keys::kIdKey, id());
   info->SetString(info_keys::kNameKey, name());
   info->SetBoolean(info_keys::kEnabledKey, enabled);
   info->SetBoolean(info_keys::kOfflineEnabledKey, offline_enabled());
   info->SetString(info_keys::kVersionKey, VersionString());
   info->SetString(info_keys::kDescriptionKey, description());
   info->SetString(info_keys::kOptionsUrlKey,
-                  options_url().possibly_invalid_spec());
+                  ExtensionURL::GetOptionsURL(this).possibly_invalid_spec());
   info->SetString(info_keys::kHomepageUrlKey,
-                  GetHomepageURL().possibly_invalid_spec());
+                  ExtensionURL::GetHomepageURL(this).possibly_invalid_spec());
   info->SetString(info_keys::kDetailsUrlKey,
                   details_url().possibly_invalid_spec());
   info->SetBoolean(info_keys::kPackagedAppKey, is_platform_app());
 }
 
 Extension::Type Extension::GetType() const {
   return converted_from_user_script() ? TYPE_USER_SCRIPT : manifest_->type();
 }
 
 // static
@@ skipping 444 matching lines @@
 }
 
 bool Extension::ShowConfigureContextMenus() const {
   // Don't show context menu for component extensions. We might want to show
   // options for component extension button but now there is no component
   // extension with options. All other menu items like uninstall have
   // no sense for component extensions.
   return location() != Extension::COMPONENT;
 }
 
-GURL Extension::GetHomepageURL() const {
-  if (homepage_url_.is_valid())
-    return homepage_url_;
-
-  return UpdatesFromGallery() ?
-      GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + id()) : GURL();
-}
-
 std::set<FilePath> Extension::GetBrowserImages() const {
   std::set<FilePath> image_paths;
   // TODO(viettrungluu): These |FilePath::FromWStringHack(UTF8ToWide())|
   // indicate that we're doing something wrong.
 
   // Extension icons.
   for (ExtensionIconSet::IconMap::const_iterator iter = icons().map().begin();
        iter != icons().map().end(); ++iter) {
     image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
   }
@@ skipping 170 matching lines @@
     return true;
 
   if (error) {
     *error = ErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      page_url.spec());
   }
   return false;
 }
 
 bool Extension::UpdatesFromGallery() const {
-  return extension_urls::IsWebstoreUpdateUrl(update_url());
+  return extension_urls::IsWebstoreUpdateUrl(ExtensionURL::GetUpdateURL(this));
 }
 
 bool Extension::OverlapsWithOrigin(const GURL& origin) const {
   if (url() == origin)
     return true;
 
   if (web_extent().is_empty())
     return false;
 
   // Note: patterns and extents ignore port numbers.
@@ skipping 12 matching lines @@
 Extension::SyncType Extension::GetSyncType() const {
   if (!IsSyncable()) {
     // We have a non-standard location.
     return SYNC_TYPE_NONE;
   }
 
   // Disallow extensions with non-gallery auto-update URLs for now.
   //
   // TODO(akalin): Relax this restriction once we've put in UI to
   // approve synced extensions.
-  if (!update_url().is_empty() && !UpdatesFromGallery())
+  if (!ExtensionURL::GetUpdateURL(this).is_empty() && !UpdatesFromGallery())
     return SYNC_TYPE_NONE;
 
   // Disallow extensions with native code plugins.
   //
   // TODO(akalin): Relax this restriction once we've put in UI to
   // approve synced extensions.
   if (!plugins().empty()) {
     return SYNC_TYPE_NONE;
   }
 
@@ skipping 738 matching lines @@
     extent_.ClearPatterns();
   }
 
   return true;
 }
 
 bool Extension::LoadSharedFeatures(
     const APIPermissionSet& api_permissions,
     string16* error) {
   if (!LoadDescription(error) ||
-      !LoadHomepageURL(error) ||
-      !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
       !LoadCommands(error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadWebAccessibleResources(error) ||
       !LoadSandboxedPages(error) ||
       !LoadRequirements(error) ||
       !LoadDefaultLocale(error) ||
       !LoadOfflineEnabled(error) ||
-      !LoadOptionsPage(error) ||
       // LoadBackgroundScripts() must be called before LoadBackgroundPage().
       !LoadBackgroundScripts(error) ||
       !LoadBackgroundPage(api_permissions, error) ||
       !LoadBackgroundPersistent(api_permissions, error) ||
       !LoadBackgroundAllowJSAccess(api_permissions, error) ||
       !LoadWebIntentServices(error) ||
       !LoadOAuth2Info(error))
     return false;
 
   return true;
@@ skipping 27 matching lines @@
           switches::kAllowLegacyExtensionManifests)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidManifestVersionOld,
         base::IntToString(kModernManifestVersion));
     return false;
   }
 
   return true;
 }
 
-bool Extension::LoadHomepageURL(string16* error) {
-  if (!manifest_->HasKey(keys::kHomepageURL))
-    return true;
-  std::string tmp_homepage_url;
-  if (!manifest_->GetString(keys::kHomepageURL, &tmp_homepage_url)) {
-    *error = ErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidHomepageURL, "");
-    return false;
-  }
-  homepage_url_ = GURL(tmp_homepage_url);
-  if (!homepage_url_.is_valid() ||
-      (!homepage_url_.SchemeIs("http") &&
-       !homepage_url_.SchemeIs("https"))) {
-    *error = ErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidHomepageURL, tmp_homepage_url);
-    return false;
-  }
-  return true;
-}
-
-bool Extension::LoadUpdateURL(string16* error) {
-  if (!manifest_->HasKey(keys::kUpdateURL))
-    return true;
-  std::string tmp_update_url;
-  if (!manifest_->GetString(keys::kUpdateURL, &tmp_update_url)) {
-    *error = ErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidUpdateURL, "");
-    return false;
-  }
-  update_url_ = GURL(tmp_update_url);
-  if (!update_url_.is_valid() ||
-      update_url_.has_ref()) {
-    *error = ErrorUtils::FormatErrorMessageUTF16(
-        errors::kInvalidUpdateURL, tmp_update_url);
-    return false;
-  }
-  return true;
-}
-
 bool Extension::LoadIcons(string16* error) {
   if (!manifest_->HasKey(keys::kIcons))
     return true;
   DictionaryValue* icons_value = NULL;
   if (!manifest_->GetDictionary(keys::kIcons, &icons_value)) {
     *error = ASCIIToUTF16(errors::kInvalidIcons);
     return false;
   }
 
   return manifest_handler_helpers::LoadIconsFromDictionary(
@@ skipping 332 matching lines @@
     offline_enabled_ = is_platform_app();
     return true;
   }
   if (!manifest_->GetBoolean(keys::kOfflineEnabled, &offline_enabled_)) {
     *error = ASCIIToUTF16(errors::kInvalidOfflineEnabled);
     return false;
   }
   return true;
 }
 
-bool Extension::LoadOptionsPage(string16* error) {
-  if (!manifest_->HasKey(keys::kOptionsPage))
-    return true;
-  std::string options_str;
-  if (!manifest_->GetString(keys::kOptionsPage, &options_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
-    return false;
-  }
-
-  if (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;
-    }
-    options_url_ = options_url;
-  } else {
-    GURL absolute(options_str);
-    if (absolute.is_valid()) {
-      *error = ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
-      return false;
-    }
-    options_url_ = GetResourceURL(options_str);
-    if (!options_url_.is_valid()) {
-      *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
-      return false;
-    }
-  }
-
-  return true;
-}
-
 bool Extension::LoadBackgroundScripts(string16* error) {
   const std::string& key = is_platform_app() ?
       keys::kPlatformAppBackgroundScripts : keys::kBackgroundScripts;
   return LoadBackgroundScripts(key, error);
 }
 
 bool Extension::LoadBackgroundScripts(const std::string& key, string16* error) {
   Value* background_scripts_value = NULL;
   if (!manifest_->Get(key, &background_scripts_value))
     return true;
@@ skipping 354 matching lines @@
   return true;
 }
 
 bool Extension::LoadExtensionFeatures(APIPermissionSet* api_permissions,
                                       string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadManifestHandlerFeatures(error) ||
-      !LoadDevToolsPage(error) ||
       !LoadInputComponents(*api_permissions, error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
       !LoadSystemIndicator(api_permissions, error) ||
       !LoadChromeURLOverrides(error) ||
       !LoadTextToSpeechVoices(error) ||
       !LoadIncognitoMode(error) ||
       !LoadFileHandlers(error) ||
       !LoadContentSecurityPolicy(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadManifestHandlerFeatures(string16* error) {
   std::vector<std::string> keys = ManifestHandler::GetKeys();
   for (size_t i = 0; i < keys.size(); ++i) {
     Value* value = NULL;
     if (!manifest_->Get(keys[i], &value)) {
       if (!ManifestHandler::Get(keys[i])->HasNoKey(this, error))
         return false;
     } else if (!ManifestHandler::Get(keys[i])->Parse(value, this, error)) {
       return false;
     }
   }
   return true;
 }
 
-bool Extension::LoadDevToolsPage(string16* error) {
-  if (!manifest_->HasKey(keys::kDevToolsPage))
-    return true;
-  std::string devtools_str;
-  if (!manifest_->GetString(keys::kDevToolsPage, &devtools_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
-    return false;
-  }
-  devtools_url_ = GetResourceURL(devtools_str);
-  return true;
-}
-
 bool Extension::LoadInputComponents(const APIPermissionSet& api_permissions,
                                     string16* error) {
   if (!manifest_->HasKey(keys::kInputComponents))
     return true;
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kInputComponents, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidInputComponents);
     return false;
   }
 
@@ skipping 1002 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions