more changes

chrome/browser/automation/testing_automation_provider.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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 2499 matching lines @@
     if (infobar->AsConfirmInfoBarDelegate()) {
       // Also covers ThemeInstalledInfoBarDelegate.
       infobar_item->SetString("type", "confirm_infobar");
       ConfirmInfoBarDelegate* confirm_infobar =
         infobar->AsConfirmInfoBarDelegate();
       infobar_item->SetString("text", confirm_infobar->GetMessageText());
       infobar_item->SetString("link_text", confirm_infobar->GetLinkText());
       ListValue* buttons_list = new ListValue;
       int buttons = confirm_infobar->GetButtons();
       if (buttons & ConfirmInfoBarDelegate::BUTTON_OK) {
-        StringValue* button_label = new StringValue(
+        StringValue* button_label = base::StringValue::New(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_OK));
         buttons_list->Append(button_label);
       }
       if (buttons & ConfirmInfoBarDelegate::BUTTON_CANCEL) {
-        StringValue* button_label = new StringValue(
+        StringValue* button_label = base::StringValue::New(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_CANCEL));
         buttons_list->Append(button_label);
       }
       infobar_item->Set("buttons", buttons_list);
     } else if (infobar->AsLinkInfoBarDelegate()) {
       infobar_item->SetString("type", "link_infobar");
       LinkInfoBarDelegate* link_infobar = infobar->AsLinkInfoBarDelegate();
       infobar_item->SetString("link_text", link_infobar->GetLinkText());
     } else if (infobar->AsTranslateInfoBarDelegate()) {
@@ skipping 885 matching lines @@
          ++type_it) {
       DictionaryValue* mime_type = new DictionaryValue();
       mime_type->SetString("mimeType", type_it->mime_type);
       mime_type->SetString("description", type_it->description);
 
       ListValue* file_extensions = new ListValue();
       for (std::vector<std::string>::const_iterator ext_it =
                type_it->file_extensions.begin();
            ext_it != type_it->file_extensions.end();
            ++ext_it) {
-        file_extensions->Append(new StringValue(*ext_it));
+        file_extensions->Append(base::StringValue::New(*ext_it));
       }
       mime_type->Set("fileExtensions", file_extensions);
 
       mime_types->Append(mime_type);
     }
     item->Set("mimeTypes", mime_types);
     items->Append(item);
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->Set("plugins", items);  // return_value owns items.
@@ skipping 683 matching lines @@
 ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
   URLPatternSet pattern_set;
   if (effective_perm)
     pattern_set = ext->GetEffectiveHostPermissions();
   else
     pattern_set = ext->GetActivePermissions()->explicit_hosts();
 
   ListValue* permissions = new ListValue;
   for (URLPatternSet::const_iterator perm = pattern_set.begin();
        perm != pattern_set.end(); ++perm) {
-    permissions->Append(new StringValue(perm->GetAsString()));
+    permissions->Append(base::StringValue::New(perm->GetAsString()));
   }
 
   return permissions;
 }
 
 ListValue* GetAPIPermissions(const Extension* ext) {
   ListValue* permissions = new ListValue;
   std::set<std::string> perm_list =
       ext->GetActivePermissions()->GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
-    permissions->Append(new StringValue(perm->c_str()));
+    permissions->Append(base::StringValue::New(perm->c_str()));
   }
   return permissions;
 }
 
 }  // namespace
 
 // Sample json input: { "command": "GetExtensionsInfo" }
 // See GetExtensionsInfo() in chrome/test/pyautolib/pyauto.py for sample json
 // output.
 void TestingAutomationProvider::GetExtensionsInfo(
@@ skipping 394 matching lines @@
     sync_info->SetString("sync url", service->sync_service_url().host());
     sync_info->SetBoolean("authenticated", status.authenticated);
     sync_info->SetString("last synced", service->GetLastSyncedTimeString());
     sync_info->SetInteger("updates received", status.updates_received);
     ListValue* synced_datatype_list = new ListValue;
     syncable::ModelTypeSet synced_datatypes;
     service->GetPreferredDataTypes(&synced_datatypes);
     for (syncable::ModelTypeSet::iterator it = synced_datatypes.begin();
          it != synced_datatypes.end(); ++it) {
       synced_datatype_list->Append(
-          new StringValue(syncable::ModelTypeToString(*it)));
+          base::StringValue::New(syncable::ModelTypeToString(*it)));
     }
     sync_info->Set("synced datatypes", synced_datatype_list);
   }
   return_value->Set("sync_info", sync_info);
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json output: { "success": true }
 void TestingAutomationProvider::AwaitSyncCycleCompletion(
     Browser* browser,
@@ skipping 209 matching lines @@
     for (std::map<AutofillFieldType, std::string>::iterator
          type_it = autofill_type_to_string.begin();
          type_it != autofill_type_to_string.end(); ++type_it) {
       std::vector<string16> value_list;
       profile->GetMultiInfo(type_it->first, &value_list);
       ListValue* values_to_return = new ListValue;
       for (std::vector<string16>::iterator value_it = value_list.begin();
            value_it != value_list.end(); ++value_it) {
         string16 value = *value_it;
         if (value.length())  // If there was something stored for that value.
-          values_to_return->Append(new StringValue(value));
+          values_to_return->Append(base::StringValue::New(value));
       }
       if (!values_to_return->empty())
         profile_info->Set(type_it->second, values_to_return);
     }
     profiles->Append(profile_info);
   }
   return profiles;
 }
 
 /* static */
@@ skipping 1088 matching lines @@
 
 void TestingAutomationProvider::GetTabIds(
     DictionaryValue* args, IPC::Message* reply_message) {
   ListValue* id_list = new ListValue();
   BrowserList::const_iterator iter = BrowserList::begin();
   for (; iter != BrowserList::end(); ++iter) {
     Browser* browser = *iter;
     for (int i = 0; i < browser->tab_count(); ++i) {
       int id = browser->GetTabContentsWrapperAt(i)->restore_tab_helper()->
           session_id().id();
-      id_list->Append(Value::CreateIntegerValue(id));
+      id_list->Append(base::NumberValue::New(id));
     }
   }
   DictionaryValue dict;
   dict.Set("ids", id_list);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsTabIdValid(
     DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
@@ skipping 240 matching lines @@
   IPC::ParamTraits<std::vector<GURL> >::Write(reply_message_, redirects_gurl);
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }