ui_overrides_handler.cc revision f8ee788a64d60abd8f2d742a5fdedde054ecd910 
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 "extensions/common/error_utils.h"
12#include "extensions/common/extension_messages.h"
13#include "extensions/common/feature_switch.h"
14#include "extensions/common/manifest_constants.h"
15#include "extensions/common/permissions/manifest_permission.h"
16#include "extensions/common/permissions/permissions_data.h"
17#include "extensions/common/permissions/permissions_info.h"
18#include "grit/generated_resources.h"
19#include "ipc/ipc_message.h"
20#include "ui/base/l10n/l10n_util.h"
21
22using extensions::api::manifest_types::ChromeUIOverrides;
23
24namespace extensions {
25
26// The manifest permission implementation supports a permission for overriding
27// the bookmark UI.
28class 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* Clone() const OVERRIDE {
67    return scoped_ptr<ManifestPermissionImpl>(
68        new ManifestPermissionImpl(
69            override_bookmarks_ui_permission_)).release();
70  }
71
72  virtual ManifestPermission* Diff(const ManifestPermission* rhs) const
73      OVERRIDE {
74    const ManifestPermissionImpl* other =
75        static_cast<const ManifestPermissionImpl*>(rhs);
76
77    return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
78        override_bookmarks_ui_permission_ &&
79        !other->override_bookmarks_ui_permission_)).release();
80  }
81
82  virtual ManifestPermission* Union(const ManifestPermission* rhs) const
83      OVERRIDE {
84    const ManifestPermissionImpl* other =
85        static_cast<const ManifestPermissionImpl*>(rhs);
86
87    return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
88        override_bookmarks_ui_permission_ ||
89        other->override_bookmarks_ui_permission_)).release();
90  }
91
92  virtual ManifestPermission* Intersect(const ManifestPermission* rhs) const
93      OVERRIDE {
94    const ManifestPermissionImpl* other =
95        static_cast<const ManifestPermissionImpl*>(rhs);
96
97    return scoped_ptr<ManifestPermissionImpl>(new ManifestPermissionImpl(
98        override_bookmarks_ui_permission_ &&
99        other->override_bookmarks_ui_permission_)).release();
100  }
101
102  virtual bool Contains(const ManifestPermission* rhs) const OVERRIDE {
103    const ManifestPermissionImpl* other =
104        static_cast<const ManifestPermissionImpl*>(rhs);
105
106    return !other->override_bookmarks_ui_permission_ ||
107        override_bookmarks_ui_permission_;
108  }
109
110  virtual bool Equal(const ManifestPermission* rhs) const OVERRIDE {
111    const ManifestPermissionImpl* other =
112        static_cast<const ManifestPermissionImpl*>(rhs);
113
114    return override_bookmarks_ui_permission_ ==
115        other->override_bookmarks_ui_permission_;
116  }
117
118  virtual void Write(IPC::Message* m) const OVERRIDE {
119    IPC::WriteParam(m, override_bookmarks_ui_permission_);
120  }
121
122  virtual bool Read(const IPC::Message* m, PickleIterator* iter) OVERRIDE {
123    return IPC::ReadParam(m, iter, &override_bookmarks_ui_permission_);
124  }
125
126  virtual void Log(std::string* log) const OVERRIDE {
127    IPC::LogParam(override_bookmarks_ui_permission_, log);
128  }
129
130 private:
131  bool override_bookmarks_ui_permission_;
132};
133
134UIOverrides::UIOverrides() {}
135
136UIOverrides::~UIOverrides() {}
137
138const UIOverrides* UIOverrides::Get(const Extension* extension) {
139  return static_cast<UIOverrides*>(
140      extension->GetManifestData(manifest_keys::kUIOverride));
141}
142
143bool UIOverrides::RemovesBookmarkButton(const Extension* extension) {
144  const UIOverrides* ui_overrides = Get(extension);
145  return ui_overrides && ui_overrides->bookmarks_ui &&
146      ui_overrides->bookmarks_ui->remove_button &&
147      *ui_overrides->bookmarks_ui->remove_button;
148}
149
150bool UIOverrides::RemovesBookmarkShortcut(const Extension* extension) {
151  const UIOverrides* ui_overrides = Get(extension);
152  return ui_overrides && ui_overrides->bookmarks_ui &&
153      ui_overrides->bookmarks_ui->remove_bookmark_shortcut &&
154      *ui_overrides->bookmarks_ui->remove_bookmark_shortcut;
155}
156
157bool UIOverrides::RemovesBookmarkOpenPagesShortcut(const Extension* extension) {
158  const UIOverrides* ui_overrides = Get(extension);
159  return ui_overrides && ui_overrides->bookmarks_ui &&
160      ui_overrides->bookmarks_ui->remove_bookmark_open_pages_shortcut &&
161      *ui_overrides->bookmarks_ui->remove_bookmark_open_pages_shortcut;
162}
163
164UIOverridesHandler::UIOverridesHandler() {}
165
166UIOverridesHandler::~UIOverridesHandler() {}
167
168bool UIOverridesHandler::Parse(Extension* extension, base::string16* error) {
169  const base::Value* dict = NULL;
170  CHECK(extension->manifest()->Get(manifest_keys::kUIOverride, &dict));
171  scoped_ptr<ChromeUIOverrides> overrides(
172      ChromeUIOverrides::FromValue(*dict, error));
173  if (!overrides)
174    return false;
175
176  scoped_ptr<UIOverrides> info(new UIOverrides);
177  info->bookmarks_ui.swap(overrides->bookmarks_ui);
178  if (!info->bookmarks_ui) {
179    *error = ErrorUtils::FormatErrorMessageUTF16(
180        manifest_errors::kInvalidEmptyDictionary,
181        manifest_keys::kUIOverride);
182    return false;
183  }
184  info->manifest_permission.reset(new ManifestPermissionImpl(
185      info->bookmarks_ui.get() != NULL));
186  extension->SetManifestData(manifest_keys::kUIOverride, info.release());
187  return true;
188}
189
190bool UIOverridesHandler::Validate(const Extension* extension,
191                                  std::string* error,
192                                  std::vector<InstallWarning>* warnings) const {
193  const UIOverrides* ui_overrides = UIOverrides::Get(extension);
194
195  if (ui_overrides && ui_overrides->bookmarks_ui) {
196    if (!FeatureSwitch::enable_override_bookmarks_ui()->IsEnabled()) {
197      warnings->push_back(InstallWarning(
198          ErrorUtils::FormatErrorMessage(
199              manifest_errors::kUnrecognizedManifestProperty,
200              manifest_keys::kBookmarkUI,
201              manifest_keys::kUIOverride)));
202    }
203  }
204
205  return true;
206}
207
208ManifestPermission* UIOverridesHandler::CreatePermission() {
209  return new ManifestPermissionImpl(false);
210}
211
212ManifestPermission* UIOverridesHandler::CreateInitialRequiredPermission(
213    const Extension* extension) {
214  const UIOverrides* data = UIOverrides::Get(extension);
215  if (data)
216    return data->manifest_permission->Clone();
217  return NULL;
218}
219const std::vector<std::string> UIOverridesHandler::Keys() const {
220  return SingleKey(manifest_keys::kUIOverride);
221}
222
223}  // namespace extensions
224