more changes

chrome/browser/extensions/extension_management_api.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_management_api.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 83 matching lines @@
     }
     info->Set("icons", icon_list);
   }
 
   const std::set<std::string> perms =
       extension.GetActivePermissions()->GetAPIsAsStrings();
   ListValue* permission_list = new ListValue();
   if (!perms.empty()) {
     std::set<std::string>::const_iterator perms_iter;
     for (perms_iter = perms.begin(); perms_iter != perms.end(); ++perms_iter) {
-      StringValue* permission_name = new StringValue(*perms_iter);
+      StringValue* permission_name = base::StringValue::New(*perms_iter);
       permission_list->Append(permission_name);
     }
   }
   info->Set("permissions", permission_list);
 
   ListValue* host_permission_list = new ListValue();
   if (!extension.is_hosted_app()) {
     // Skip host permissions for hosted apps.
     const URLPatternSet host_perms =
         extension.GetActivePermissions()->explicit_hosts();
     if (!host_perms.is_empty()) {
       URLPatternSet::const_iterator host_perms_iter;
       for (host_perms_iter = host_perms.begin();
            host_perms_iter != host_perms.end();
            ++host_perms_iter) {
-        StringValue* name = new StringValue(host_perms_iter->GetAsString());
+        StringValue* name =
+            base::StringValue::New(host_perms_iter->GetAsString());
         host_permission_list->Append(name);
       }
     }
   }
   info->Set("hostPermissions", host_permission_list);
 
   return info;
 }
 
 static void AddExtensionInfo(ListValue* list,
@@ skipping 44 matching lines @@
   if (!extension) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(kNoExtensionError,
                                                        ext_id);
     return false;
   }
 
   ExtensionPermissionMessages warnings = extension->GetPermissionMessages();
   ListValue* result = new ListValue();
   for (ExtensionPermissionMessages::const_iterator i = warnings.begin();
        i < warnings.end(); ++i)
-    result->Append(Value::CreateStringValue(i->message()));
+    result->Append(base::StringValue::New(i->message()));
   result_.reset(result);
   return true;
 }
 
 namespace {
 
 // This class helps GetPermissionWarningsByManifestFunction manage
 // sending manifest JSON strings to the utility process for parsing.
 class SafeManifestJSONParser : public UtilityProcessHost::Client {
  public:
@@ skipping 105 matching lines @@
       Extension::STRICT_ERROR_CHECKS, &error_);
   if (!extension.get()) {
     OnParseFailure(kExtensionCreateError);
     return;
   }
 
   ExtensionPermissionMessages warnings = extension->GetPermissionMessages();
   ListValue* result = new ListValue();
   for (ExtensionPermissionMessages::const_iterator i = warnings.begin();
        i < warnings.end(); ++i)
-    result->Append(Value::CreateStringValue(i->message()));
+    result->Append(base::StringValue::New(i->message()));
   result_.reset(result);
   SendResponse(true);
 
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
 void GetPermissionWarningsByManifestFunction::OnParseFailure(
     const std::string& error) {
   error_ = error;
@@ skipping 131 matching lines @@
       break;
     default:
       NOTREACHED();
       return;
   }
 
   ListValue args;
   if (event_name == events::kOnExtensionUninstalled) {
     const std::string& extension_id =
         Details<UninstalledExtensionInfo>(details).ptr()->extension_id;
-    args.Append(Value::CreateStringValue(extension_id));
+    args.Append(base::StringValue::New(extension_id));
   } else {
     const Extension* extension = NULL;
     if (event_name == events::kOnExtensionDisabled) {
       extension = Details<UnloadedExtensionInfo>(details)->extension;
     } else {
       extension = Details<const Extension>(details).ptr();
     }
     CHECK(extension);
     ExtensionService* service = profile->GetExtensionService();
     bool enabled = service->GetExtensionById(extension->id(), false) != NULL;
     args.Append(CreateExtensionInfo(*extension, enabled));
   }
 
   std::string args_json;
   base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name, args_json, NULL, GURL());
 }