| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef CHROME_BROWSER_EXTENSIONS_MANAGEMENT_POLICY_H_ | |
| 6 #define CHROME_BROWSER_EXTENSIONS_MANAGEMENT_POLICY_H_ | |
| 7 | |
| 8 #include <set> | |
| 9 #include <string> | |
| 10 | |
| 11 #include "base/basictypes.h" | |
| 12 #include "extensions/common/extension.h" | |
| 13 | |
| 14 namespace extensions { | |
| 15 | |
| 16 // This class registers providers that want to prohibit certain actions from | |
| 17 // being applied to extensions. It must be called, via the ExtensionService, | |
| 18 // before allowing a user or a user-level mechanism to perform the respective | |
| 19 // action. (That is, installing or otherwise modifying an extension in order | |
| 20 // to conform to enterprise administrator policy must be exempted from these | |
| 21 // checks.) | |
| 22 // | |
| 23 // This "policy" and its providers should not be confused with administrator | |
| 24 // policy, although admin policy is one of the sources ("Providers") of | |
| 25 // restrictions registered with and exposed by the ManagementPolicy. | |
| 26 class ManagementPolicy { | |
| 27 public: | |
| 28 // Each mechanism that wishes to limit users' ability to control extensions, | |
| 29 // whether one individual extension or the whole system, should implement | |
| 30 // the methods of this Provider interface that it needs. In each case, if the | |
| 31 // provider does not need to control a certain action, that method does not | |
| 32 // need to be implemented. | |
| 33 // | |
| 34 // It is not guaranteed that a particular Provider's methods will be called | |
| 35 // each time a user tries to perform one of the controlled actions (the list | |
| 36 // of providers is short-circuited as soon as a decision is possible), so | |
| 37 // implementations of these methods must have no side effects. | |
| 38 // | |
| 39 // For all of the Provider methods below, if |error| is not NULL and the | |
| 40 // method imposes a restriction on the desired action, |error| may be set | |
| 41 // to an applicable error message, but this is not required. | |
| 42 class Provider { | |
| 43 public: | |
| 44 Provider() {} | |
| 45 virtual ~Provider() {} | |
| 46 | |
| 47 // A human-readable name for this provider, for use in debug messages. | |
| 48 // Implementers should return an empty string in non-debug builds, to save | |
| 49 // executable size. | |
| 50 virtual std::string GetDebugPolicyProviderName() const = 0; | |
| 51 | |
| 52 // Providers should return false if a user may not install the |extension|, | |
| 53 // or load or run it if it has already been installed. | |
| 54 virtual bool UserMayLoad(const Extension* extension, | |
| 55 string16* error) const; | |
| 56 | |
| 57 // Providers should return false if a user may not enable, disable, or | |
| 58 // uninstall the |extension|, or change its usage options (incognito | |
| 59 // permission, file access, etc.). | |
| 60 virtual bool UserMayModifySettings(const Extension* extension, | |
| 61 string16* error) const; | |
| 62 | |
| 63 // Providers should return true if the |extension| must always remain | |
| 64 // enabled. This is distinct from UserMayModifySettings() in that the latter | |
| 65 // also prohibits enabling the extension if it is currently disabled. | |
| 66 // Providers implementing this method should also implement the others | |
| 67 // above, if they wish to completely lock in an extension. | |
| 68 virtual bool MustRemainEnabled(const Extension* extension, | |
| 69 string16* error) const; | |
| 70 | |
| 71 // Similar to MustRemainEnabled, but for whether an extension must remain | |
| 72 // disabled, and returns an error and/or reason if the caller needs it. | |
| 73 virtual bool MustRemainDisabled(const Extension* extension, | |
| 74 Extension::DisableReason* reason, | |
| 75 string16* error) const; | |
| 76 | |
| 77 private: | |
| 78 DISALLOW_COPY_AND_ASSIGN(Provider); | |
| 79 }; | |
| 80 | |
| 81 ManagementPolicy(); | |
| 82 ~ManagementPolicy(); | |
| 83 | |
| 84 // Registers or unregisters a provider, causing it to be added to or removed | |
| 85 // from the list of providers queried. Ownership of the provider remains with | |
| 86 // the caller. Providers do not need to be unregistered on shutdown. | |
| 87 void RegisterProvider(Provider* provider); | |
| 88 void UnregisterProvider(Provider* provider); | |
| 89 | |
| 90 // Returns true if the user is permitted to install, load, and run the given | |
| 91 // extension. If not, |error| may be set to an appropriate message. | |
| 92 bool UserMayLoad(const Extension* extension, string16* error) const; | |
| 93 | |
| 94 // Returns true if the user is permitted to enable, disable, or uninstall the | |
| 95 // given extension, or change the extension's usage options (incognito mode, | |
| 96 // file access, etc.). If not, |error| may be set to an appropriate message. | |
| 97 bool UserMayModifySettings(const Extension* extension, | |
| 98 string16* error) const; | |
| 99 | |
| 100 // Returns true if the extension must remain enabled at all times (e.g. a | |
| 101 // compoment extension). In that case, |error| may be set to an appropriate | |
| 102 // message. | |
| 103 bool MustRemainEnabled(const Extension* extension, | |
| 104 string16* error) const; | |
| 105 | |
| 106 // Returns true immediately if any registered provider's MustRemainDisabled | |
| 107 // function returns true. | |
| 108 bool MustRemainDisabled(const Extension* extension, | |
| 109 Extension::DisableReason* reason, | |
| 110 string16* error) const; | |
| 111 | |
| 112 // For use in testing. | |
| 113 void UnregisterAllProviders(); | |
| 114 int GetNumProviders() const; | |
| 115 | |
| 116 private: | |
| 117 // This is a pointer to a function in the Provider interface, used in | |
| 118 // ApplyToProviderList. | |
| 119 typedef bool (Provider::*ProviderFunction)(const Extension*, string16*) const; | |
| 120 | |
| 121 typedef std::set<Provider*> ProviderList; | |
| 122 | |
| 123 // This is a helper to apply a method in the Provider interface to each of | |
| 124 // the Provider objects in |providers_|. The return value of this function | |
| 125 // will be |normal_result|, unless any of the Provider calls to |function| | |
| 126 // return !normal_result, in which case this function will then early-return | |
| 127 // !normal_result. | |
| 128 bool ApplyToProviderList(ProviderFunction function, | |
| 129 const char* debug_operation_name, | |
| 130 bool normal_result, | |
| 131 const Extension* extension, | |
| 132 string16* error) const; | |
| 133 | |
| 134 ProviderList providers_; | |
| 135 | |
| 136 DISALLOW_COPY_AND_ASSIGN(ManagementPolicy); | |
| 137 }; | |
| 138 | |
| 139 } // namespace extensions | |
| 140 | |
| 141 #endif // CHROME_BROWSER_EXTENSIONS_MANAGEMENT_POLICY_H_ | |
| OLD | NEW |