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

chrome/browser/extensions/extension_sidebar_api.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/browser/extensions/extension_sidebar_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sidebar/sidebar_container.h"
 #include "chrome/browser/sidebar/sidebar_manager.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_sidebar_utils.h"
 #include "chrome/common/render_messages.h"
-#include "chrome/common/url_constants.h"
 #include "ipc/ipc_message_utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace {
 // Errors.
+const char kNoSidebarError[] =
+    "This extension has no sidebar specified.";
 const char kNoTabError[] = "No tab with id: *.";
-const char kInvalidUrlError[] = "Invalid url: \"*\".";
 const char kNoCurrentWindowError[] = "No current browser window was found";
 const char kNoDefaultTabError[] = "No default tab was found";
 const char kInvalidExpandContextError[] =
     "Sidebar can be expanded only in response to an explicit user gesture";
 // Keys.
 const char kBadgeTextKey[] = "text";
 const char kImageDataKey[] = "imageData";
 const char kStateKey[] = "state";
 const char kTabIdKey[] = "tabId";
 const char kTitleKey[] = "title";
 const char kUrlKey[] = "url";
 // Events.
 const char kOnStateChanged[] = "experimental.sidebar.onStateChanged";
 }  // namespace
 
 namespace extension_sidebar_constants {
 // Sidebar states.
 const char kActiveState[] = "active";
 const char kHiddenState[] = "hidden";
 const char kShownState[] = "shown";
-}
-
-static GURL ResolvePossiblyRelativeURL(const std::string& url_string,
-                                       const Extension* extension) {
-  GURL url = GURL(url_string);
-  if (!url.is_valid())
-    url = extension->GetResourceURL(url_string);
-
-  return url;
-}
-
-static bool CanUseHost(const Extension* extension,
-                       const GURL& url,
-                       std::string* error) {
-  if (extension->HasHostPermission(url))
-      return true;
-
-  if (error) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(
-        extension_manifest_errors::kCannotAccessPage, url.spec());
-  }
-
-  return false;
-}
-
+}  // namespace extension_sidebar_constants
 
 // static
 void ExtensionSidebarEventRouter::OnStateChanged(
     Profile* profile, TabContents* tab, const std::string& content_id,
     const std::string& state) {
   int tab_id = ExtensionTabUtil::GetTabId(tab);
   DictionaryValue* details = new DictionaryValue;
   details->Set(kTabIdKey, Value::CreateIntegerValue(tab_id));
   details->Set(kStateKey, Value::CreateStringValue(state));
 
   ListValue args;
   args.Set(0, details);
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
 
-  const std::string& extension_id(content_id);
   profile->GetExtensionEventRouter()->DispatchEventToExtension(
-      extension_id, kOnStateChanged, json_args, profile, GURL());
+      extension_sidebar_utils::GetExtensionIdByContentId(content_id),
+      kOnStateChanged, json_args, profile, GURL());
 }
 
 
 // List is considered empty if it is actually empty or contains just one value,
 // either 'null' or 'undefined'.
 static bool IsArgumentListEmpty(const ListValue* arguments) {
   if (arguments->empty())
     return true;
   if (arguments->GetSize() == 1) {
     Value* first_value = 0;
     if (!arguments->Get(0, &first_value))
       return true;
     if (first_value->GetType() == Value::TYPE_NULL)
       return true;
   }
   return false;
 }
 
 bool SidebarFunction::RunImpl() {
+  if (!GetExtension()->sidebar_defaults()) {
+    error_ = kNoSidebarError;
+    return false;
+  }
+
   if (!args_.get())
     return false;
 
   DictionaryValue* details = NULL;
   DictionaryValue default_details;
   if (IsArgumentListEmpty(args_.get())) {
     details = &default_details;
   } else {
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
   }
@@ skipping 93 matching lines @@
                                   const DictionaryValue& details) {
   SidebarManager::GetInstance()->HideSidebar(tab, content_id);
   return true;
 }
 
 bool NavigateSidebarFunction::RunImpl(TabContents* tab,
                                       const std::string& content_id,
                                       const DictionaryValue& details) {
   std::string url_string;
   EXTENSION_FUNCTION_VALIDATE(details.GetString(kUrlKey, &url_string));
-  GURL url = ResolvePossiblyRelativeURL(url_string, GetExtension());
-  if (!url.is_valid()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(kInvalidUrlError,
-                                                     url_string);
+
+  GURL url = extension_sidebar_utils::ResolveAndVerifyUrl(
+      url_string, GetExtension(), &error_);
+  if (!url.is_valid())
     return false;
-  }
-  if (!url.SchemeIs(chrome::kExtensionScheme) &&
-      !CanUseHost(GetExtension(), url, &error_)) {
-    return false;
-  }
-  // Disallow requests outside of the requesting extension view's extension.
-  if (url.SchemeIs(chrome::kExtensionScheme)) {
-    std::string extension_id(url.host());
-    if (extension_id != GetExtension()->id())
-      return false;
-  }
 
-  SidebarManager::GetInstance()->NavigateSidebar(tab, content_id, GURL(url));
+  SidebarManager::GetInstance()->NavigateSidebar(tab, content_id, url);
   return true;
 }
 
 bool SetBadgeTextSidebarFunction::RunImpl(TabContents* tab,
                                           const std::string& content_id,
                                           const DictionaryValue& details) {
   string16 badge_text;
   EXTENSION_FUNCTION_VALIDATE(details.GetString(kBadgeTextKey, &badge_text));
   SidebarManager::GetInstance()->SetSidebarBadgeText(
       tab, content_id, badge_text);
@@ skipping 22 matching lines @@
   SidebarManager::GetInstance()->SetSidebarTitle(tab, content_id, title);
   return true;
 }
 
 bool ShowSidebarFunction::RunImpl(TabContents* tab,
                                   const std::string& content_id,
                                   const DictionaryValue& details) {
   SidebarManager::GetInstance()->ShowSidebar(tab, content_id);
   return true;
 }