Move Icons out of Extension class

chrome/common/extensions/extension.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 
 #include <algorithm>
 #include <iosfwd>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
+#include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/extensions/permissions/api_permission_set.h"
 #include "chrome/common/extensions/permissions/permission_message.h"
 #include "chrome/common/extensions/user_script.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/gurl.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/size.h"
 
 class ExtensionAction;
-class ExtensionResource;
 class SkBitmap;
 class Version;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace gfx {
 class ImageSkia;
@@ skipping 209 matching lines @@
       const base::DictionaryValue& value,
       int flags,
       const std::string& explicit_id,
       std::string* error);
 
   // Given two install sources, return the one which should take priority
   // over the other. If an extension is installed from two sources A and B,
   // its install source should be set to GetHigherPriorityLocation(A, B).
   static Location GetHigherPriorityLocation(Location loc1, Location loc2);
 
-  // Max size (both dimensions) for browser and page actions.
-  static const int kPageActionIconMaxSize;
-  static const int kBrowserActionIconMaxSize;
-
   // Valid schemes for web extent URLPatterns.
   static const int kValidWebExtentSchemes;
 
   // Valid schemes for host permission URLPatterns.
   static const int kValidHostPermissionSchemes;
 
   // The name of the manifest inside an extension.
   static const FilePath::CharType kManifestFilename[];
 
   // The name of locale folder inside an extension.
@@ skipping 100 matching lines @@
   // always generate the same output ID.
   static bool GenerateId(const std::string& input,
                          std::string* output) WARN_UNUSED_RESULT;
 
   // Expects base64 encoded |input| and formats into |output| including
   // the appropriate header & footer.
   static bool FormatPEMForFileOutput(const std::string& input,
                                      std::string* output,
                                      bool is_public);
 
-  // Given an extension, icon size, and match type, read a valid icon if present
-  // and decode it into result. In the browser process, this will DCHECK if not
-  // called on the file thread. To easily load extension images on the UI
-  // thread, see ImageLoadingTracker.
-  static void DecodeIcon(const Extension* extension,
-                         int icon_size,
-                         ExtensionIconSet::MatchType match_type,
-                         scoped_ptr<SkBitmap>* result);
-
-  // Given an extension and icon size, read it if present and decode it into
-  // result. In the browser process, this will DCHECK if not called on the
-  // file thread. To easily load extension images on the UI thread, see
-  // ImageLoadingTracker.
-  static void DecodeIcon(const Extension* extension,
-                         int icon_size,
-                         scoped_ptr<SkBitmap>* result);
-
-  // Given an icon_path and icon size, read it if present and decode it into
-  // result. In the browser process, this will DCHECK if not called on the
-  // file thread. To easily load extension images on the UI thread, see
-  // ImageLoadingTracker.
-  static void DecodeIconFromPath(const FilePath& icon_path,
-                                 int icon_size,
-                                 scoped_ptr<SkBitmap>* result);
-
-  // Returns the default extension/app icon (for extensions or apps that don't
-  // have one).
-  static const gfx::ImageSkia& GetDefaultIcon(bool is_app);
-
   // Returns the base extension url for a given |extension_id|.
   static GURL GetBaseURLFromExtensionId(const std::string& extension_id);
 
   // Adds an extension to the scripting whitelist. Used for testing only.
   static void SetScriptingWhitelist(const ScriptingWhitelist& whitelist);
   static const ScriptingWhitelist* GetScriptingWhitelist();
 
   // Parses the host and api permissions from the specified permission |key|
   // from |manifest_|.
   bool ParsePermissions(const char* key,
@@ skipping 54 matching lines @@
   // Gets the extension's active permission set.
   scoped_refptr<const PermissionSet> GetActivePermissions() const;
 
   // Whether context menu should be shown for page and browser actions.
   bool ShowConfigureContextMenus() const;
 
   // Returns a list of paths (relative to the extension dir) for images that
   // the browser might load (like themes and page action icons).
   std::set<FilePath> GetBrowserImages() const;
 
-  // Get an extension icon as a resource or URL.
-  ExtensionResource GetIconResource(
-      int size, ExtensionIconSet::MatchType match_type) const;
-  GURL GetIconURL(int size, ExtensionIconSet::MatchType match_type) const;
-
   // Gets the fully resolved absolute launch URL.
   GURL GetFullLaunchURL() const;
 
   // Image cache related methods. These are only valid on the UI thread and
   // not maintained by this class. See ImageLoadingTracker for usage. The
   // |original_size| parameter should be the size of the image at |source|
   // before any scaling may have been done to produce the pixels in |image|.
   void SetCachedImage(const ExtensionResource& source,
                       const SkBitmap& image,
                       const gfx::Size& original_size) const;
@@ skipping 154 matching lines @@
   }
   const PermissionSet* required_permission_set() const {
     return required_permission_set_.get();
   }
   // Appends |new_warning[s]| to install_warnings_.
   void AddInstallWarning(const InstallWarning& new_warning);
   void AddInstallWarnings(const InstallWarningVector& new_warnings);
   const InstallWarningVector& install_warnings() const {
     return install_warnings_;
   }
-  const ExtensionIconSet& icons() const { return icons_; }
   const extensions::Manifest* manifest() const {
     return manifest_.get();
   }
   const std::string default_locale() const { return default_locale_; }
   bool incognito_split_mode() const { return incognito_split_mode_; }
   bool offline_enabled() const { return offline_enabled_; }
   const OAuth2Info& oauth2_info() const { return oauth2_info_; }
   bool wants_file_access() const { return wants_file_access_; }
   int creation_flags() const { return creation_flags_; }
   bool from_webstore() const { return (creation_flags_ & FROM_WEBSTORE) != 0; }
@@ skipping 118 matching lines @@
                   const char* list_error,
                   const char* value_error,
                   string16* error);
   bool LoadLaunchContainer(string16* error);
   bool LoadLaunchURL(string16* error);
 
   bool LoadSharedFeatures(const APIPermissionSet& api_permissions,
                           string16* error);
   bool LoadDescription(string16* error);
   bool LoadManifestVersion(string16* error);
-  bool LoadIcons(string16* error);
   bool LoadCommands(string16* error);
   bool LoadPlugins(string16* error);
   bool LoadNaClModules(string16* error);
   bool LoadWebAccessibleResources(string16* error);
   bool LoadSandboxedPages(string16* error);
   // Must be called after LoadPlugins().
   bool LoadRequirements(string16* error);
   bool LoadDefaultLocale(string16* error);
   bool LoadOfflineEnabled(string16* error);
   bool LoadBackgroundScripts(string16* error);
@@ skipping 135 matching lines @@
 
   // The set of permissions the extension can request at runtime.
   scoped_refptr<const PermissionSet> optional_permission_set_;
 
   // The extension's required / default set of permissions.
   scoped_refptr<const PermissionSet> required_permission_set_;
 
   // Any warnings that occurred when trying to create/parse the extension.
   InstallWarningVector install_warnings_;
 
-  // The icons for the extension.
-  ExtensionIconSet icons_;
-
   // The base extension url for the extension.
   GURL extension_url_;
 
   // The extension's version.
   scoped_ptr<Version> version_;
 
   // An optional longer description of the extension.
   std::string description_;
 
   // True if the extension was generated from a user script. (We show slightly
@@ skipping 193 matching lines @@
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const PermissionSet* permissions,
       Reason reason);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_