Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

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/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
+#include "chrome/common/extensions/manifest.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/install_warning.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;
 }
 
 FORWARD_DECLARE_TEST(TabStripModelTest, Apps);
 
 namespace extensions {
 struct ActionInfo;
-class Manifest;
 class PermissionSet;
 
 typedef std::set<std::string> OAuth2Scopes;
 
 // Represents a Chrome extension.
 class Extension : public base::RefCountedThreadSafe<Extension> {
  public:
-  struct InstallWarning;
   struct ManifestData;
 
   typedef std::vector<std::string> ScriptingWhitelist;
-  typedef std::vector<InstallWarning> InstallWarningVector;
   typedef std::map<const std::string, linked_ptr<ManifestData> >
       ManifestDataMap;
 
-  // What an extension was loaded from.
-  // NOTE: These values are stored as integers in the preferences and used
-  // in histograms so don't remove or reorder existing items.  Just append
-  // to the end.
-  enum Location {
-    INVALID,
-    INTERNAL,           // A crx file from the internal Extensions directory.
-    EXTERNAL_PREF,      // A crx file from an external directory (via prefs).
-    EXTERNAL_REGISTRY,  // A crx file from an external directory (via eg the
-                        // registry on Windows).
-    LOAD,               // --load-extension.
-    COMPONENT,          // An integral component of Chrome itself, which
-                        // happens to be implemented as an extension. We don't
-                        // show these in the management UI.
-    EXTERNAL_PREF_DOWNLOAD,    // A crx file from an external directory (via
-                               // prefs), installed from an update URL.
-    EXTERNAL_POLICY_DOWNLOAD,  // A crx file from an external directory (via
-                               // admin policies), installed from an update URL.
-
-    NUM_LOCATIONS
-  };
-
   enum State {
     DISABLED = 0,
     ENABLED,
     // An external extension that the user uninstalled. We should not reinstall
     // such extensions on startup.
     EXTERNAL_EXTENSION_UNINSTALLED,
     // Special state for component extensions, since they are always loaded by
     // the component loader, and should never be auto-installed on startup.
     ENABLED_COMPONENT,
     NUM_STATES
@@ skipping 19 matching lines @@
   };
 
   enum InstallType {
     INSTALL_ERROR,
     DOWNGRADE,
     REINSTALL,
     UPGRADE,
     NEW_INSTALL
   };
 
-  // Do not change the order of entries or remove entries in this list
-  // as this is used in UMA_HISTOGRAM_ENUMERATIONs about extensions.
-  enum Type {
-    TYPE_UNKNOWN = 0,
-    TYPE_EXTENSION,
-    TYPE_THEME,
-    TYPE_USER_SCRIPT,
-    TYPE_HOSTED_APP,
-    // This is marked legacy because platform apps are preferred. For
-    // backwards compatibility, we can't remove support for packaged apps
-    TYPE_LEGACY_PACKAGED_APP,
-    TYPE_PLATFORM_APP
-  };
-
   enum SyncType {
     SYNC_TYPE_NONE = 0,
     SYNC_TYPE_EXTENSION,
     SYNC_TYPE_APP
   };
 
   // Declared requirements for the extension.
   struct Requirements {
     Requirements();
     ~Requirements();
@@ skipping 19 matching lines @@
   struct OAuth2Info {
     OAuth2Info();
     ~OAuth2Info();
 
     OAuth2Scopes GetScopesAsSet();
 
     std::string client_id;
     std::vector<std::string> scopes;
   };
 
-  struct InstallWarning {
-    enum Format {
-      // IMPORTANT: Do not build HTML strings from user or developer-supplied
-      // input.
-      FORMAT_TEXT,
-      FORMAT_HTML,
-    };
-    InstallWarning(Format format, const std::string& message)
-        : format(format), message(message) {
-    }
-    bool operator==(const InstallWarning& other) const;
-    Format format;
-    std::string message;
-  };
-
   // A base class for parsed manifest data that APIs want to store on
   // the extension. Related to base::SupportsUserData, but with an immutable
   // thread-safe interface to match Extension.
   struct ManifestData {
     virtual ~ManifestData() {}
   };
 
   enum InitFromValueFlags {
     NO_FLAGS = 0,
 
@@ skipping 29 matching lines @@
     // |ERROR_ON_PRIVATE_KEY| means that private keys inside an
     // extension should be errors rather than warnings.
     ERROR_ON_PRIVATE_KEY = 1 << 6,
 
     // |WAS_INSTALLED_BY_DEFAULT| installed by default when the profile was
     // created.
     WAS_INSTALLED_BY_DEFAULT = 1 << 7,
   };
 
   static scoped_refptr<Extension> Create(const FilePath& path,
-                                         Location location,
+                                         Manifest::Location location,
                                          const base::DictionaryValue& value,
                                          int flags,
                                          std::string* error);
 
   // In a few special circumstances, we want to create an Extension and give it
   // an explicit id. Most consumers should just use the other Create() method.
   static scoped_refptr<Extension> Create(const FilePath& path,
-      Location location,
+      Manifest::Location location,
       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;
 
@@ skipping 19 matching lines @@
   // Checks to see if the extension has a valid ID.
   static bool IdIsValid(const std::string& id);
 
   // Generate an ID for an extension in the given path.
   // Used while developing extensions, before they have a key.
   static std::string GenerateIdForPath(const FilePath& file_name);
 
   // Returns true if the specified file is an extension.
   static bool IsExtension(const FilePath& file_name);
 
-  // Whether the |location| is external or not.
-  static inline bool IsExternalLocation(Location location) {
-    return location == Extension::EXTERNAL_PREF ||
-           location == Extension::EXTERNAL_REGISTRY ||
-           location == Extension::EXTERNAL_PREF_DOWNLOAD ||
-           location == Extension::EXTERNAL_POLICY_DOWNLOAD;
-  }
-
-  // Whether extensions with |location| are auto-updatable or not.
-  static inline bool IsAutoUpdateableLocation(Location location) {
-    // Only internal and external extensions can be autoupdated.
-    return location == Extension::INTERNAL ||
-           IsExternalLocation(location);
-  }
-
-  // Unpacked extensions start off with file access since they are a developer
-  // feature.
-  static inline bool ShouldAlwaysAllowFileAccess(Location location) {
-    return location == Extension::LOAD;
-  }
-
   // Fills the |info| dictionary with basic information about the extension.
   // |enabled| is injected for easier testing.
   void GetBasicInfo(bool enabled, base::DictionaryValue* info) const;
 
-  // See Type definition above.
-  Type GetType() const;
+  // See Type definition in Manifest.
+  Manifest::Type GetType() const;
 
   // Returns an absolute url to a resource inside of an extension. The
   // |extension_url| argument should be the url() from an Extension object. The
   // |relative_path| can be untrusted user input. The returned URL will either
   // be invalid() or a child of |extension_url|.
   // NOTE: Static so that it can be used from multiple threads.
   static GURL GetResourceURL(const GURL& extension_url,
                              const std::string& relative_path);
   GURL GetResourceURL(const std::string& relative_path) const {
     return GetResourceURL(url(), relative_path);
@@ skipping 238 matching lines @@
   // Sets |data| to be associated with the key. Takes ownership of |data|.
   // Can only be called before InitValue is finished. Not thread-safe;
   // all SetManifestData calls should be on only one thread.
   void SetManifestData(const std::string& key, ManifestData* data);
 
   // Accessors:
 
   const Requirements& requirements() const { return requirements_; }
   const FilePath& path() const { return path_; }
   const GURL& url() const { return extension_url_; }
-  Location location() const;
+  Manifest::Location location() const;
   const std::string& id() const;
   const Version* version() const { return version_.get(); }
   const std::string VersionString() const;
   const std::string& name() const { return name_; }
   const std::string& non_localized_name() const { return non_localized_name_; }
   // Base64-encoded version of the key used to sign this extension.
   // In pseudocode, returns
   // base::Base64Encode(RSAPrivateKey(pem_file).ExportPublicKey()).
   const std::string& public_key() const { return public_key_; }
   const std::string& description() const { return description_; }
@@ skipping 26 matching lines @@
     return has_background_page() && !background_page_is_persistent_;
   }
   const PermissionSet* optional_permission_set() const {
     return optional_permission_set_.get();
   }
   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 {
+  void AddInstallWarnings(const std::vector<InstallWarning>& new_warnings);
+  const std::vector<InstallWarning>& install_warnings() const {
     return install_warnings_;
   }
   const ExtensionIconSet& icons() const { return icons_; }
   const extensions::Manifest* manifest() const {
     return manifest_.get();
   }
   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_; }
@@ skipping 268 matching lines @@
   mutable base::Lock runtime_data_lock_;
   mutable RuntimeData runtime_data_;
 
   // 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_;
+  std::vector<InstallWarning> 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_;
 
@@ skipping 125 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ExtensionTest, LoadPageActionHelper);
   FRIEND_TEST_ALL_PREFIXES(::TabStripModelTest, Apps);
 
   DISALLOW_COPY_AND_ASSIGN(Extension);
 };
 
 typedef std::vector< scoped_refptr<const Extension> > ExtensionList;
 typedef std::set<std::string> ExtensionIdSet;
 typedef std::vector<std::string> ExtensionIdList;
 
-// Let gtest print InstallWarnings.
-void PrintTo(const Extension::InstallWarning&, ::std::ostream* os);
-
 // Handy struct to pass core extension info around.
 struct ExtensionInfo {
   ExtensionInfo(const base::DictionaryValue* manifest,
                 const std::string& id,
                 const FilePath& path,
-                Extension::Location location);
+                Manifest::Location location);
   ~ExtensionInfo();
 
   scoped_ptr<base::DictionaryValue> extension_manifest;
   std::string extension_id;
   FilePath extension_path;
-  Extension::Location extension_location;
+  Manifest::Location extension_location;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionInfo);
 };
 
 struct UnloadedExtensionInfo {
   extension_misc::UnloadedExtensionReason reason;
 
   // Was the extension already disabled?
   bool already_disabled;
@@ skipping 25 matching lines @@
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const PermissionSet* permissions,
       Reason reason);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_