| // Copyright 2014 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. |
| // |
| // This file declares extension specific l10n utils. |
| |
| #ifndef EXTENSIONS_COMMON_EXTENSION_L10N_UTIL_H_ |
| #define EXTENSIONS_COMMON_EXTENSION_L10N_UTIL_H_ |
| |
| #include <set> |
| #include <string> |
| #include <vector> |
| |
| #include "base/auto_reset.h" |
| #include "base/strings/string_piece.h" |
| #include "extensions/common/manifest.h" |
| |
| namespace base { |
| class DictionaryValue; |
| class FilePath; |
| } |
| |
| namespace extensions { |
| class Extension; |
| class MessageBundle; |
| } |
| |
| namespace extension_l10n_util { |
| |
| enum class GzippedMessagesPermission { |
| // Do not allow gzipped locale ('messages.json') files. |
| kDisallow, |
| // Allow gzipped locale files. This should only be set for trusted sources, |
| // e.g. component extensions from the Chrome OS rootfs. |
| kAllowForTrustedSource, |
| }; |
| |
| // Returns GzippedMessagesPermission::kAllowForTrustedSource for component |
| // extensions, otherwise returns kDisallow. |
| GzippedMessagesPermission GetGzippedMessagesPermissionForExtension( |
| const extensions::Extension* extension); |
| |
| // Returns GzippedMessagesPermission::kAllowForTrustedSource for trusted |
| // manifest locations, otherwise returns kDisallow. |
| GzippedMessagesPermission GetGzippedMessagesPermissionForLocation( |
| extensions::Manifest::Location location); |
| |
| // Called from tests to temporarily allow loading gzipped messages for non |
| // component test extensions. |
| base::AutoReset<bool> AllowGzippedMessagesAllowedForTest(); |
| |
| // Set the locale for this process to a fixed value, rather than using the |
| // normal file-based lookup mechanisms. This is used to set the locale inside |
| // the sandboxed utility process, where file reading is not allowed. |
| void SetProcessLocale(const std::string& locale); |
| |
| // Sets the preferred locale. This is the user-preferred locale, which may |
| // differ from the actual process locale in use, like when a preferred locale of |
| // "en-CA" is mapped to a process locale of "en-GB". |
| void SetPreferredLocale(const std::string& locale); |
| |
| // Returns default locale in form "en-US" or "sr" or empty string if |
| // "default_locale" section was not defined in the manifest.json file. |
| std::string GetDefaultLocaleFromManifest(const base::DictionaryValue& manifest, |
| std::string* error); |
| |
| // Returns true iff the extension was localized, and the current locale |
| // doesn't match the locale written into info.extension_manifest. |
| bool ShouldRelocalizeManifest(const base::DictionaryValue* manifest); |
| |
| // Localize extension name, description, browser_action and other fields |
| // in the manifest. |
| bool LocalizeManifest(const extensions::MessageBundle& messages, |
| base::DictionaryValue* manifest, |
| std::string* error); |
| |
| // Load message catalogs, localize manifest and attach message bundle to the |
| // extension. |gzip_permission| will be passed to LoadMessageCatalogs |
| // (see below for details). |
| bool LocalizeExtension(const base::FilePath& extension_path, |
| base::DictionaryValue* manifest, |
| GzippedMessagesPermission gzip_permission, |
| std::string* error); |
| |
| // Adds locale_name to the extension if it's in chrome_locales, and |
| // if messages file is present (we don't check content of messages file here). |
| // Returns false if locale_name was not found in chrome_locales, and sets |
| // error with locale_name. |
| // If file name starts with . return true (helps testing extensions under svn). |
| bool AddLocale(const std::set<std::string>& chrome_locales, |
| const base::FilePath& locale_folder, |
| const std::string& locale_name, |
| std::set<std::string>* valid_locales, |
| std::string* error); |
| |
| // Returns normalized current locale, or default locale - en_US. |
| std::string CurrentLocaleOrDefault(); |
| |
| // Extends list of Chrome locales to them and their parents, so we can do |
| // proper fallback. |
| void GetAllLocales(std::set<std::string>* all_locales); |
| |
| // Provides a vector of all fallback locales for message localization. |
| // The vector is ordered by priority of locale - application locale, |
| // first_parent, ..., |default_locale|. |
| void GetAllFallbackLocales(const std::string& default_locale, |
| std::vector<std::string>* all_fallback_locales); |
| |
| // Fill |valid_locales| with all valid locales under |locale_path|. |
| // |valid_locales| is the intersection of the set of locales supported by |
| // Chrome and the set of locales specified by |locale_path|. |
| // Returns true if vaild_locales contains at least one locale, false otherwise. |
| // |error| contains an error message when a locale is corrupt or missing. |
| bool GetValidLocales(const base::FilePath& locale_path, |
| std::set<std::string>* valid_locales, |
| std::string* error); |
| |
| // Loads messages file for the default locale and application locales |
| // (application locales do not have to exist). Application locales include the |
| // current locale and its parents. If |gzip_permission| is |
| // kAllowForTrustedSource, this will look for compressed messages files and |
| // decompress them if they exist. Returns the message bundle if it can load the |
| // default locale messages file and all messages are valid. Otherwise returns |
| // null and sets |error|. |
| extensions::MessageBundle* LoadMessageCatalogs( |
| const base::FilePath& locale_path, |
| const std::string& default_locale, |
| GzippedMessagesPermission gzip_permission, |
| std::string* error); |
| |
| // Loads message catalogs for all locales to check for validity. Used for |
| // validating unpacked extensions. |
| bool ValidateExtensionLocales(const base::FilePath& extension_path, |
| const base::DictionaryValue* manifest, |
| std::string* error); |
| |
| // Returns true if directory has "." in the name (for .svn) or if it doesn't |
| // belong to Chrome locales. |
| // |locales_path| is extension_id/_locales |
| // |locale_path| is extension_id/_locales/xx |
| // |all_locales| is a set of all valid Chrome locales. |
| bool ShouldSkipValidation(const base::FilePath& locales_path, |
| const base::FilePath& locale_path, |
| const std::set<std::string>& all_locales); |
| |
| // Sets the process and preferred locale for the duration of the current scope, |
| // then reverts back to whatever the current values were before constructing |
| // this. For testing purposed only! |
| class ScopedLocaleForTest { |
| public: |
| // Only revert back to current locale at end of scope, don't set locale. |
| ScopedLocaleForTest(); |
| |
| // Sets temporary locale for the current scope. |
| explicit ScopedLocaleForTest(base::StringPiece locale); |
| |
| // Sets process and preferred locales for the current scope. |
| ScopedLocaleForTest(base::StringPiece process_locale, |
| base::StringPiece preferred_locale); |
| |
| ~ScopedLocaleForTest(); |
| |
| private: |
| base::StringPiece process_locale_; // The process locale at ctor time. |
| base::StringPiece preferred_locale_; // The preferred locale at ctor time. |
| }; |
| |
| // Returns a locale like "en-CA". |
| const std::string& GetPreferredLocaleForTest(); |
| |
| } // namespace extension_l10n_util |
| |
| #endif // EXTENSIONS_COMMON_EXTENSION_L10N_UTIL_H_ |