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 187 matching lines @@
 
     // |FROM_BOOKMARK| indicates the extension was created using a mock App
     // created from a bookmark.
     FROM_BOOKMARK = 1 << 5,
   };
 
   static scoped_refptr<Extension> Create(const FilePath& path,
                                          Location location,
                                          const base::DictionaryValue& value,
                                          int flags,
-                                         std::string* error);
+                                         std::string* std_error);

[Aaron Boodman, 2011/12/15 02:25:36]

No need to change this. If it makes implementation sense for the name in the cc
file to be different, that's fine. But no need to leak that implementation
detail into the header.

 
   // In a few special circumstances, we want to create an Extension and give it
   // an explicit id. Most consumers should just use the plain Create() method.
   static scoped_refptr<Extension> CreateWithId(
       const FilePath& path,
       Location location,
       const base::DictionaryValue& value,
       int flags,
       const std::string& explicit_id,
       std::string* error);
@@ skipping 152 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_