src/chrome/common/extensions/manifest_handlers/ui_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/ui_overrides_handler.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/values.h"
  11 #include "chrome/grit/generated_resources.h"
  12 #include "extensions/common/error_utils.h"
  13 #include "extensions/common/extension_messages.h"
  14 #include "extensions/common/feature_switch.h"
  15 #include "extensions/common/manifest_constants.h"
  16 #include "extensions/common/permissions/manifest_permission.h"
  17 #include "extensions/common/permissions/permissions_data.h"
  18 #include "extensions/common/permissions/permissions_info.h"
  19 #include "ipc/ipc_message.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21
  22 using extensions::api::manifest_types::ChromeUIOverrides;
  23
  24 namespace extensions {
  25
  26 // The manifest permission implementation supports a permission for overriding
  27 // the bookmark UI.
  28 class UIOverridesHandler::ManifestPermissionImpl : public ManifestPermission {
  29  public:
  30   explicit ManifestPermissionImpl(bool override_bookmarks_ui_permission)
  31       : override_bookmarks_ui_permission_(override_bookmarks_ui_permission) {}
  32
  33   // extensions::ManifestPermission overrides.
  34   virtual std::string name() const OVERRIDE {
  35     return manifest_keys::kUIOverride;
  36   }
  37
  38   virtual std::string id() const OVERRIDE {
  39     return name();
  40   }
  41
  42   virtual bool HasMessages() const OVERRIDE {
  43     return override_bookmarks_ui_permission_;
  44   }
  45
  46   virtual PermissionMessages GetMessages() const OVERRIDE {
  47     PermissionMessages result;
  48     if (override_bookmarks_ui_permission_) {
  49       result.push_back(PermissionMessage(
  50           PermissionMessage::kOverrideBookmarksUI,
  51           l10n_util::GetStringUTF16(
  52               IDS_EXTENSION_PROMPT_WARNING_OVERRIDE_BOOKMARKS_UI)));
  53     }
  54     return result;
  55   }
  56
  57   virtual bool FromValue(const base::Value* value) OVERRIDE {
  58     return value && value->GetAsBoolean(&override_bookmarks_ui_permission_);
  59   }
  60
  61   virtual scoped_ptr<base::Value> ToValue() const OVERRIDE {
  62     return scoped_ptr<base::Value>(
  63         new base::FundamentalValue(override_bookmarks_ui_permission_)).Pass();
  64   }
  65
  66   virtual ManifestPermission* Diff(const ManifestPermission* rhs) const
  67       OVERRIDE {
  68     const ManifestPermissionImpl* other =
  69         static_cast<const ManifestPermissionImpl*>(rhs);
  70
  71     return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
  72         override_bookmarks_ui_permission_ &&
  73         !other->override_bookmarks_ui_permission_)).release();
  74   }
  75
  76   virtual ManifestPermission* Union(const ManifestPermission* rhs) const
  77       OVERRIDE {
  78     const ManifestPermissionImpl* other =
  79         static_cast<const ManifestPermissionImpl*>(rhs);
  80
  81     return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
  82         override_bookmarks_ui_permission_ ||
  83         other->override_bookmarks_ui_permission_)).release();
  84   }
  85
  86   virtual ManifestPermission* Intersect(const ManifestPermission* rhs) const
  87       OVERRIDE {
  88     const ManifestPermissionImpl* other =
  89         static_cast<const ManifestPermissionImpl*>(rhs);
  90
  91     return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
  92         override_bookmarks_ui_permission_ &&
  93         other->override_bookmarks_ui_permission_)).release();
  94   }
  95
  96  private:
  97   bool override_bookmarks_ui_permission_;
  98 };
  99
 100 UIOverrides::UIOverrides() {}
 101
 102 UIOverrides::~UIOverrides() {}
 103
 104 const UIOverrides* UIOverrides::Get(const Extension* extension) {
 105   return static_cast<UIOverrides*>(
 106       extension->GetManifestData(manifest_keys::kUIOverride));
 107 }
 108
 109 bool UIOverrides::RemovesBookmarkButton(const Extension* extension) {
 110   const UIOverrides* ui_overrides = Get(extension);
 111   return ui_overrides && ui_overrides->bookmarks_ui &&
 112       ui_overrides->bookmarks_ui->remove_button &&
 113       *ui_overrides->bookmarks_ui->remove_button;
 114 }
 115
 116 bool UIOverrides::RemovesBookmarkShortcut(const Extension* extension) {
 117   const UIOverrides* ui_overrides = Get(extension);
 118   return ui_overrides && ui_overrides->bookmarks_ui &&
 119       ui_overrides->bookmarks_ui->remove_bookmark_shortcut &&
 120       *ui_overrides->bookmarks_ui->remove_bookmark_shortcut;
 121 }
 122
 123 bool UIOverrides::RemovesBookmarkOpenPagesShortcut(const Extension* extension) {
 124   const UIOverrides* ui_overrides = Get(extension);
 125   return ui_overrides && ui_overrides->bookmarks_ui &&
 126       ui_overrides->bookmarks_ui->remove_bookmark_open_pages_shortcut &&
 127       *ui_overrides->bookmarks_ui->remove_bookmark_open_pages_shortcut;
 128 }
 129
 130 UIOverridesHandler::UIOverridesHandler() {}
 131
 132 UIOverridesHandler::~UIOverridesHandler() {}
 133
 134 bool UIOverridesHandler::Parse(Extension* extension, base::string16* error) {
 135   const base::Value* dict = NULL;
 136   CHECK(extension->manifest()->Get(manifest_keys::kUIOverride, &dict));
 137   scoped_ptr<ChromeUIOverrides> overrides(
 138       ChromeUIOverrides::FromValue(*dict, error));
 139   if (!overrides)
 140     return false;
 141
 142   scoped_ptr<UIOverrides> info(new UIOverrides);
 143   info->bookmarks_ui.swap(overrides->bookmarks_ui);
 144   if (!info->bookmarks_ui) {
 145     *error = ErrorUtils::FormatErrorMessageUTF16(
 146         manifest_errors::kInvalidEmptyDictionary,
 147         manifest_keys::kUIOverride);
 148     return false;
 149   }
 150   info->manifest_permission.reset(new ManifestPermissionImpl(
 151       info->bookmarks_ui.get() != NULL));
 152   extension->SetManifestData(manifest_keys::kUIOverride, info.release());
 153   return true;
 154 }
 155
 156 bool UIOverridesHandler::Validate(const Extension* extension,
 157                                   std::string* error,
 158                                   std::vector<InstallWarning>* warnings) const {
 159   const UIOverrides* ui_overrides = UIOverrides::Get(extension);
 160
 161   if (ui_overrides && ui_overrides->bookmarks_ui) {
 162     if (!FeatureSwitch::enable_override_bookmarks_ui()->IsEnabled()) {
 163       warnings->push_back(InstallWarning(
 164           ErrorUtils::FormatErrorMessage(
 165               manifest_errors::kUnrecognizedManifestProperty,
 166               manifest_keys::kBookmarkUI,
 167               manifest_keys::kUIOverride)));
 168     }
 169   }
 170
 171   return true;
 172 }
 173
 174 ManifestPermission* UIOverridesHandler::CreatePermission() {
 175   return new ManifestPermissionImpl(false);
 176 }
 177
 178 ManifestPermission* UIOverridesHandler::CreateInitialRequiredPermission(
 179     const Extension* extension) {
 180   const UIOverrides* data = UIOverrides::Get(extension);
 181   if (data)
 182     return data->manifest_permission->Clone();
 183   return NULL;
 184 }
 185 const std::vector<std::string> UIOverridesHandler::Keys() const {
 186   return SingleKey(manifest_keys::kUIOverride);
 187 }
 188
 189 }  // namespace extensions