src/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc

   1 // Copyright 2013 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_handlers/settings_overrides_handler.h"
   6
   7 #include "base/strings/string_util.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/common/extensions/permissions/permissions_data.h"
  10 #include "chrome/common/extensions/permissions/settings_override_permission.h"
  11 #include "extensions/common/error_utils.h"
  12 #include "extensions/common/manifest_constants.h"
  13 #include "extensions/common/permissions/api_permission_set.h"
  14 #include "extensions/common/permissions/permissions_info.h"
  15 #include "url/gurl.h"
  16
  17 using extensions::api::manifest_types::ChromeSettingsOverrides;
  18
  19 namespace extensions {
  20 namespace {
  21
  22 const char* kWwwPrefix = "www.";
  23
  24 scoped_ptr<GURL> CreateManifestURL(const std::string& url) {
  25   scoped_ptr<GURL> manifest_url(new GURL(url));
  26   if (!manifest_url->is_valid() ||
  27       !manifest_url->SchemeIsHTTPOrHTTPS())
  28     return scoped_ptr<GURL>();
  29   return manifest_url.Pass();
  30 }
  31
  32 scoped_ptr<GURL> ParseHomepage(const ChromeSettingsOverrides& overrides,
  33                                string16* error) {
  34   if (!overrides.homepage)
  35     return scoped_ptr<GURL>();
  36   scoped_ptr<GURL> manifest_url = CreateManifestURL(*overrides.homepage);
  37   if (!manifest_url) {
  38     *error = extensions::ErrorUtils::FormatErrorMessageUTF16(
  39         manifest_errors::kInvalidHomepageOverrideURL, *overrides.homepage);
  40   }
  41   return manifest_url.Pass();
  42 }
  43
  44 std::vector<GURL> ParseStartupPage(const ChromeSettingsOverrides& overrides,
  45                                    string16* error) {
  46   std::vector<GURL> urls;
  47   if (!overrides.startup_pages)
  48     return urls;
  49
  50   for (std::vector<std::string>::const_iterator i =
  51        overrides.startup_pages->begin(); i != overrides.startup_pages->end();
  52        ++i) {
  53     scoped_ptr<GURL> manifest_url = CreateManifestURL(*i);
  54     if (!manifest_url) {
  55       *error = extensions::ErrorUtils::FormatErrorMessageUTF16(
  56           manifest_errors::kInvalidStartupOverrideURL, *i);
  57     } else {
  58       urls.push_back(GURL());
  59       urls.back().Swap(manifest_url.get());
  60     }
  61   }
  62   return urls;
  63 }
  64
  65 // A www. prefix is not informative and thus not worth the limited real estate
  66 // in the permissions UI.
  67 std::string RemoveWwwPrefix(const std::string& url) {
  68   if (StartsWithASCII(url, kWwwPrefix, false))
  69     return url.substr(strlen(kWwwPrefix));
  70   return url;
  71 }
  72
  73 }  // namespace
  74
  75 SettingsOverrides::SettingsOverrides() {}
  76
  77 SettingsOverrides::~SettingsOverrides() {}
  78
  79 const SettingsOverrides* SettingsOverrides::Get(
  80     const Extension* extension) {
  81   return static_cast<SettingsOverrides*>(
  82       extension->GetManifestData(manifest_keys::kSettingsOverride));
  83 }
  84
  85 SettingsOverridesHandler::SettingsOverridesHandler() {}
  86
  87 SettingsOverridesHandler::~SettingsOverridesHandler() {}
  88
  89 bool SettingsOverridesHandler::Parse(Extension* extension, string16* error) {
  90   const base::Value* dict = NULL;
  91   CHECK(extension->manifest()->Get(manifest_keys::kSettingsOverride, &dict));
  92   scoped_ptr<ChromeSettingsOverrides> settings(
  93       ChromeSettingsOverrides::FromValue(*dict, error));
  94   if (!settings)
  95     return false;
  96
  97   scoped_ptr<SettingsOverrides> info(new SettingsOverrides);
  98   info->homepage = ParseHomepage(*settings, error);
  99   info->search_engine = settings->search_provider.Pass();
 100   info->startup_pages = ParseStartupPage(*settings, error);
 101   if (!info->homepage && !info->search_engine && info->startup_pages.empty()) {
 102     *error = ASCIIToUTF16(manifest_errors::kInvalidEmptySettingsOverrides);
 103     return false;
 104   }
 105   APIPermissionSet* permission_set =
 106       PermissionsData::GetInitialAPIPermissions(extension);
 107   DCHECK(permission_set);
 108   if (info->search_engine) {
 109     permission_set->insert(new SettingsOverrideAPIPermission(
 110         PermissionsInfo::GetInstance()->GetByID(APIPermission::kSearchProvider),
 111         RemoveWwwPrefix(CreateManifestURL(info->search_engine->search_url)->
 112             GetOrigin().host())));
 113   }
 114   if (!info->startup_pages.empty()) {
 115     permission_set->insert(new SettingsOverrideAPIPermission(
 116         PermissionsInfo::GetInstance()->GetByID(APIPermission::kStartupPages),
 117         // We only support one startup page even though the type of the manifest
 118         // property is a list, only the first one is used.
 119         RemoveWwwPrefix(info->startup_pages[0].GetContent())));
 120   }
 121   if (info->homepage) {
 122     permission_set->insert(new SettingsOverrideAPIPermission(
 123         PermissionsInfo::GetInstance()->GetByID(APIPermission::kHomepage),
 124         RemoveWwwPrefix(info->homepage.get()->GetContent())));
 125   }
 126   extension->SetManifestData(manifest_keys::kSettingsOverride,
 127                              info.release());
 128   return true;
 129 }
 130
 131 const std::vector<std::string> SettingsOverridesHandler::Keys() const {
 132   return SingleKey(manifest_keys::kSettingsOverride);
 133 }
 134
 135 }  // namespace extensions