Add extension permissions for new settings override API.

chrome/common/extensions/permissions/settings_override_permission.cc

Index: chrome/common/extensions/permissions/settings_override_permission.cc
diff --git a/chrome/common/extensions/permissions/settings_override_permission.cc b/chrome/common/extensions/permissions/settings_override_permission.cc
new file mode 100644
index 0000000000000000000000000000000000000000..09a99469c7d7263b2e60506d845e3692d82ac2c6
--- /dev/null
+++ b/chrome/common/extensions/permissions/settings_override_permission.cc
@@ -0,0 +1,115 @@
+// Copyright (c) 2013 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/permissions/settings_override_permission.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+
+namespace extensions {
+
+SettingsOverrideAPIPermission::SettingsOverrideAPIPermission(
+    const APIPermissionInfo* permission, const std::string& setting_value)
+    : APIPermission(permission),
+      setting_value_(setting_value) {
+}
+
+SettingsOverrideAPIPermission::~SettingsOverrideAPIPermission() {
+}
+
+bool SettingsOverrideAPIPermission::HasMessages() const {
+  return info()->message_id() > PermissionMessage::kNone;
+}
+
+PermissionMessages SettingsOverrideAPIPermission::GetMessages() const {
+  DCHECK(HasMessages());
+  int string_id = -1;
+  switch (id()) {
+    case kHomePage: {
+      string_id = IDS_EXTENSION_PROMPT_WARNING_HOME_PAGE_SETTING_OVERRIDE;
+      break;
+    }
+    case kStartupPages: {
+      string_id = IDS_EXTENSION_PROMPT_WARNING_START_PAGE_SETTING_OVERRIDE;
+      break;
+    }
+    case kSearchSettings: {
+      string_id = IDS_EXTENSION_PROMPT_WARNING_SEARCH_SETTINGS_OVERRIDE;
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+  PermissionMessages result;
+  result.push_back(PermissionMessage(
+      info()->message_id(),
+      l10n_util::GetStringFUTF16(string_id, UTF8ToUTF16(setting_value_))));
+  return result;
+}
+
+bool SettingsOverrideAPIPermission::Check(
+    const APIPermission::CheckParam* param) const {
+  return !param;
+}
+
+bool SettingsOverrideAPIPermission::Contains(const APIPermission* rhs) const {
+  CHECK(info() == rhs->info());

[robertshield, 2013/11/04 01:11:13]

I see other implementers of APIPermission CHECK on unexpected params, though I
couldn't tell why this was a good idea (it wasn't spelled out in
api_permission.h). If you've encountered the reasoning, please could you add an
explanatory comment.

[MAD, 2013/11/04 02:06:34]

I honestly don't know. I can only guess that these calls are only allowed across
compatible permissions, i.e., with the same info. But it's only a guess, I
simply blindly copied the code from SimpleAPIPermission.

I could ask the OWNERS when the CR gets to that level.

[robertshield, 2013/11/04 02:29:01]

I would do the same :)
Sgtm. I was mainly curious.

+  return true;
+}
+
+bool SettingsOverrideAPIPermission::Equal(const APIPermission* rhs) const {
+  if (this == rhs)
+    return true;
+  CHECK(info() == rhs->info());
+  return true;
+}
+
+bool SettingsOverrideAPIPermission::FromValue(const base::Value* value) {
+  // This should never be called since we create the permission manually
+  // because it's not one explicitly set in the manifest file, it's implicitly
+  // added when settings overrides are used.
+  NOTREACHED();
+  return false;
+}
+
+scoped_ptr<base::Value> SettingsOverrideAPIPermission::ToValue() const {
+  return scoped_ptr<base::Value>();
+}
+
+APIPermission* SettingsOverrideAPIPermission::Clone() const {
+  return new SettingsOverrideAPIPermission(info(), setting_value_);
+}
+
+APIPermission* SettingsOverrideAPIPermission::Diff(
+    const APIPermission* rhs) const {
+  CHECK(info() == rhs->info());
+  return NULL;
+}
+
+APIPermission* SettingsOverrideAPIPermission::Union(
+    const APIPermission* rhs) const {
+  CHECK(info() == rhs->info());
+  return new SettingsOverrideAPIPermission(info(), setting_value_);
+}
+
+APIPermission* SettingsOverrideAPIPermission::Intersect(
+    const APIPermission* rhs) const {
+  CHECK(info() == rhs->info());
+  return new SettingsOverrideAPIPermission(info(), setting_value_);
+}
+
+void SettingsOverrideAPIPermission::Write(IPC::Message* m) const {
+}
+
+bool SettingsOverrideAPIPermission::Read(
+    const IPC::Message* m, PickleIterator* iter) {
+  return true;
+}
+
+void SettingsOverrideAPIPermission::Log(std::string* log) const {
+}
+
+}  // namespace extensions