Add "sidebar" section to extension manifest:...

chrome/common/extensions/extension_sidebar_utils.cc

+// Copyright (c) 2010 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_sidebar_utils.h"
+
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/url_constants.h"
+#include "googleurl/src/gurl.h"
+
+namespace {
+
+// Errors.
+const char kInvalidUrlError[] = "Invalid url: \"*\".";
+
+bool CanUseHost(const Extension* extension,
+                const GURL& url,
+                std::string* error) {
+  if (extension->HasHostPermission(url))

[Aaron Boodman, 2011/01/20 00:36:11]

This is overloading the meaning of host permissions. The current meaning is that
an extension has access to do authenticated cross-origin XHR to that host. I
think it's a bad idea to use the same permission to mean two different things.

The simplest thing to do for v1 would be to only allow extension pages to be
displayed in sidebars. That is consistent with how the rest of the system works.
If developers want to override this they can always embed an iframe that
references their remote page.

That would mean changing the URL fields in the manifest to be paths, more like
the rest of the system.

[Aleksey Shlyapnikov, 2011/01/20 02:41:43]

As chromium.org says, "Many extension capabilities, such as cross-origin
XMLHttpRequests, programmatically injected content scripts, and the cookies API
require host permissions", and it's even even to check access rights to
chrome://favicon/ url (if
(extension->HasHostPermission(GURL(chrome::kChromeUIFavIconURL))) ...).
I assumed that sidebar is one of "many extension capabilities", that's why
permissions are used there.
Ultimately I think you're correct and we should not overload concepts, but I
would really like to be sure that permissions are misused before I start
renaming a bunch of variables and functions.


On 2011/01/20 00:36:11, Aaron Boodman wrote:

[Aaron Boodman, 2011/01/20 17:53:16]

Yup. All of these are basically the same permission -- they all grant what we
call 'authenticated access' to the data on the site. That is, the extension can
act on the site on behalf of the user via all these APIs; that is why they all
have the same permission.
This one was a huge mistake that has caused us endless heartache. I would still
like to undo it. This is how we learned that it was a terrible idea to overload
what the hosts permissions are giving access to.
Also, if you agree that we should not support remote URLs for the contents of
sidebars (just like we don't for all other surfaces in extensions), then this is
mostly a delete of code. You don't need an extra permission at all, and much of
sidebar_utils can be removed, I think.

+    return true;
+
+  *error = ExtensionErrorUtils::FormatErrorMessage(
+      extension_manifest_errors::kCannotAccessPage, url.spec());
+  return false;
+}
+
+}  // namespace
+
+namespace extension_sidebar_utils {
+
+std::string GetExtensionIdByContentId(const std::string& content_id) {
+  // At the moment, content_id == extension_id.
+  return content_id;
+}
+
+GURL ResolveAndVerifyUrl(const std::string& url_string,
+                         const Extension* extension,
+                         std::string* error) {
+  // Resolve possibly relative URL.
+  GURL url(url_string);
+  if (!url.is_valid())
+    url = extension->GetResourceURL(url_string);
+
+  if (!url.is_valid()) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidUrlError,
+                                                     url_string);
+    return GURL();
+  }
+  if (!url.SchemeIs(chrome::kExtensionScheme) &&
+      !CanUseHost(extension, url, error)) {
+    return GURL();
+  }
+  // Disallow requests outside of the requesting extension view's extension.
+  if (url.SchemeIs(chrome::kExtensionScheme)) {
+    std::string extension_id(url.host());
+    if (extension_id != extension->id())
+      return GURL();
+  }
+
+  return url;
+}
+
+}  // namespace extension_sidebar_utils