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

chrome/common/extensions/extension.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/scoped_ptr.h"
 #include "base/ref_counted.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_extent.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "gfx/size.h"
 #include "googleurl/src/gurl.h"
 
 class DictionaryValue;
 class ExtensionAction;
 class ExtensionResource;
+class ExtensionSidebarDefaults;
 class SkBitmap;
 class Version;
 
 // Represents a Chrome extension.
 class Extension : public base::RefCountedThreadSafe<Extension> {
  public:
   typedef std::map<const std::string, GURL> URLOverrideMap;
   typedef std::vector<std::string> ScriptingWhitelist;
 
   // What an extension was loaded from.
@@ skipping 105 matching lines @@
   // to |old_list|.
   static bool IsElevatedHostList(
       const URLPatternList& old_list, const URLPatternList& new_list);
 
   // Icon sizes used by the extension system.
   static const int kIconSizes[];
 
   // Max size (both dimensions) for browser and page actions.
   static const int kPageActionIconMaxSize;
   static const int kBrowserActionIconMaxSize;
+  static const int kSidebarIconMaxSize;
 
   // Each permission is a module that the extension is permitted to use.
   //
   // NOTE: To add a new permission, define it here, and add an entry to
   // Extension::kPermissions.
   static const char kBackgroundPermission[];
   static const char kBookmarkPermission[];
   static const char kContextMenusPermission[];
   static const char kCookiePermission[];
   static const char kExperimentalPermission[];
@@ skipping 243 matching lines @@
   const std::string VersionString() const;
   const std::string& name() const { return name_; }
   const std::string& public_key() const { return public_key_; }
   const std::string& description() const { return description_; }
   bool converted_from_user_script() const {
     return converted_from_user_script_;
   }
   const UserScriptList& content_scripts() const { return content_scripts_; }
   ExtensionAction* page_action() const { return page_action_.get(); }
   ExtensionAction* browser_action() const { return browser_action_.get(); }
+  ExtensionSidebarDefaults* sidebar_defaults() const {
+    return sidebar_defaults_.get();
+  }
   const std::vector<PluginInfo>& plugins() const { return plugins_; }
   const GURL& background_url() const { return background_url_; }
   const GURL& options_url() const { return options_url_; }
   const GURL& devtools_url() const { return devtools_url_; }
   const std::vector<GURL>& toolstrips() const { return toolstrips_; }
   const std::set<std::string>& api_permissions() const {
     return api_permissions_;
   }
   const URLPatternList& host_permissions() const { return host_permissions_; }
   const GURL& update_url() const { return update_url_; }
@@ skipping 99 matching lines @@
                   const char* value_error, std::string* error);
   bool LoadLaunchContainer(const DictionaryValue* manifest, std::string* error);
   bool LoadLaunchURL(const DictionaryValue* manifest, std::string* error);
   bool EnsureNotHybridApp(const DictionaryValue* manifest, std::string* error);
 
   // Helper method to load an ExtensionAction from the page_action or
   // browser_action entries in the manifest.
   ExtensionAction* LoadExtensionActionHelper(
       const DictionaryValue* extension_action, std::string* error);
 
+  // Helper method to load a ExtensionSidebarDefaults from the sidebar manifest
+  // entry.
+  ExtensionSidebarDefaults* LoadExtensionSidebarDefaults(
+      const DictionaryValue* sidebar, std::string* error);
+
   // Calculates the effective host permissions from the permissions and content
   // script petterns.
   void InitEffectiveHostPermissions();
 
   // Returns true if the extension has more than one "UI surface". For example,
   // an extension that has a browser action and a page action.
   bool HasMultipleUISurfaces() const;
 
   // Figures out if a source contains keys not associated with themes - we
   // don't want to allow scripts and such to be bundled with themes.
@@ skipping 73 matching lines @@
 
   // Paths to the content scripts the extension contains.
   UserScriptList content_scripts_;
 
   // The extension's page action, if any.
   scoped_ptr<ExtensionAction> page_action_;
 
   // The extension's browser action, if any.
   scoped_ptr<ExtensionAction> browser_action_;
 
+  // The extension's sidebar, if any.
+  scoped_ptr<ExtensionSidebarDefaults> sidebar_defaults_;
+
   // Optional list of NPAPI plugins and associated properties.
   std::vector<PluginInfo> plugins_;
 
   // Optional URL to a master page of which a single instance should be always
   // loaded in the background.
   GURL background_url_;
 
   // Optional URL to a page for setting options/preferences.
   GURL options_url_;
 
@@ skipping 117 matching lines @@
   // Was the extension already disabled?
   bool already_disabled;
 
   // The extension being unloaded - this should always be non-NULL.
   const Extension* extension;
 
   UnloadedExtensionInfo(const Extension* extension, Reason reason);
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_