Issue 71980: Extensions code should use UTF-16 for user-visible Unicode strings

chrome/common/extensions/extension.h

 // Copyright (c) 2011 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>
@@ skipping 363 matching lines @@
 
   // 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|
   // in the manifest |source|.
   bool ParsePermissions(const extensions::Manifest* source,
                         const char* key,
                         int flags,
-                        std::string* error,
+                        string16* error,
                         ExtensionAPIPermissionSet* api_permissions,
                         URLPatternSet* host_permissions);
 
   bool HasAPIPermission(ExtensionAPIPermission::ID permission) const;
   bool HasAPIPermission(const std::string& function_name) const;
 
   const URLPatternSet& GetEffectiveHostPermissions() const;
 
   // Returns true if the extension can silently increase its permission level.
   // Extensions that can silently increase permissions are installed through
@@ skipping 220 matching lines @@
 
   // Returns true if this extension id is from a trusted provider.
   static bool IsTrustedId(const std::string& id);
 
   Extension(const FilePath& path, Location location);
   ~Extension();
 
   // Initialize the extension from a parsed manifest.
   // Takes ownership of the manifest |value|.
   bool InitFromValue(extensions::Manifest* value, int flags,
-                     std::string* error);
+                     string16* error);
 
   // Helper function for implementing HasCachedImage/GetCachedImage. A return
   // value of NULL means there is no matching image cached (we allow caching an
   // empty SkBitmap).
   SkBitmap* GetCachedImageImpl(const ExtensionResource& source,
                                const gfx::Size& max_size) const;
 
   // Helper method that loads a UserScript object from a
   // dictionary in the content_script list of the manifest.
   bool LoadUserScriptHelper(const base::DictionaryValue* content_script,
                             int definition_index,
                             int flags,
-                            std::string* error,
+                            string16* error,
                             UserScript* result);
 
   // Helper method that loads either the include_globs or exclude_globs list
   // from an entry in the content_script lists of the manifest.
   bool LoadGlobsHelper(const base::DictionaryValue* content_script,
                        int content_script_index,
                        const char* globs_property_name,
-                       std::string* error,
+                       string16* error,
                        void(UserScript::*add_method)(const std::string& glob),
                        UserScript *instance);
 
   // Helpers to load various chunks of the manifest.
   bool LoadExtent(const extensions::Manifest* manifest,
                   const char* key,
                   URLPatternSet* extent,
                   const char* list_error,
                   const char* value_error,
                   URLPattern::ParseOption parse_option,
-                  std::string* error);
+                  string16* error);
   bool LoadLaunchContainer(const extensions::Manifest* manifest,
-                           std::string* error);
+                           string16* error);
   bool LoadLaunchURL(const extensions::Manifest* manifest,
-                     std::string* error);
+                     string16* error);
   bool LoadAppIsolation(const extensions::Manifest* manifest,
-                        std::string* error);
+                        string16* error);
   bool LoadWebIntentServices(const extensions::Manifest* manifest,
-                             std::string* error);
+                             string16* error);
 
   // Helper method to load an ExtensionAction from the page_action or
   // browser_action entries in the manifest.
   ExtensionAction* LoadExtensionActionHelper(
-      const base::DictionaryValue* extension_action, std::string* error);
+      const base::DictionaryValue* extension_action, string16* error);
 
   // Helper method to load an FileBrowserHandlerList from the manifest.
   FileBrowserHandlerList* LoadFileBrowserHandlers(
-      const base::ListValue* extension_actions, std::string* error);
+      const base::ListValue* extension_actions, string16* error);
   // Helper method to load an FileBrowserHandler from manifest.
   FileBrowserHandler* LoadFileBrowserHandler(
-      const base::DictionaryValue* file_browser_handlers, std::string* error);
+      const base::DictionaryValue* file_browser_handlers, string16* error);
 
   // Helper method to load an ExtensionSidebarDefaults from the sidebar manifest
   // entry.
   ExtensionSidebarDefaults* LoadExtensionSidebarDefaults(
-      const base::DictionaryValue* sidebar, std::string* error);
+      const base::DictionaryValue* sidebar, string16* error);
 
   // 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;
 
   // Updates the launch URL and extents for the extension using the given
   // |override_url|.
   void OverrideLaunchUrl(const GURL& override_url);
 
   // Returns true if this extension can specify |api|.
   bool CanSpecifyAPIPermission(const ExtensionAPIPermission* api,
-                               std::string* error) const;
+                               string16* error) const;
   bool CanSpecifyComponentOnlyPermission() const;
   bool CanSpecifyExperimentalPermission() const;
 
   // Checks whether the host |pattern| is allowed for this extension, given API
   // permissions |permissions|.
   bool CanSpecifyHostPermission(const URLPattern& pattern,
       const ExtensionAPIPermissionSet& permissions) const;
 
   // Cached images for this extension. This should only be touched on the UI
   // thread.
@@ skipping 230 matching lines @@
   // only contain the removed permissions.
   const ExtensionPermissionSet* permissions;
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const ExtensionPermissionSet* permissions,
       Reason reason);
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_