more changes

chrome/browser/sync/engine/syncapi.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/sync/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 1162 matching lines @@
     }
     node_value = node_dict;
   } else {
     ReadNode node(trans);
     if (node.InitByIdLookup(id)) {
       node_value = node.GetDetailsAsValue();
     }
   }
   if (!node_value) {
     NOTREACHED();
-    node_value = Value::CreateNullValue();
+    node_value = base::NullValue();
   }
   value->Set("node", node_value);
   return value;
 }
 
 SyncManager::ExtraPasswordChangeRecordData::ExtraPasswordChangeRecordData() {}
 
 SyncManager::ExtraPasswordChangeRecordData::ExtraPasswordChangeRecordData(
     const sync_pb::PasswordSpecificsData& data)
     : unencrypted_(data) {
@@ skipping 1550 matching lines @@
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
 JsArgList SyncManager::SyncInternal::GetNotificationState(
     const JsArgList& args) {
   bool notifications_enabled = allstatus_.status().notifications_enabled;
   ListValue return_args;
-  return_args.Append(Value::CreateBooleanValue(notifications_enabled));
+  return_args.Append(base::BooleanValue::New(notifications_enabled));
   return JsArgList(&return_args);
 }
 
 JsArgList SyncManager::SyncInternal::GetNotificationInfo(
     const JsArgList& args) {
   ListValue return_args;
   return_args.Append(NotificationInfoToValue(notification_info_map_));
   return JsArgList(&return_args);
 }
 
@@ skipping 65 matching lines @@
   ListValue* child_ids = new ListValue();
   return_args.Append(child_ids);
   int64 id = GetId(args.Get(), 0);
   if (id != kInvalidId) {
     ReadTransaction trans(FROM_HERE, GetUserShare());
     syncable::Directory::ChildHandles child_handles;
     trans.GetLookup()->GetChildHandlesByHandle(trans.GetWrappedTrans(),
                                                id, &child_handles);
     for (syncable::Directory::ChildHandles::const_iterator it =
              child_handles.begin(); it != child_handles.end(); ++it) {
-      child_ids->Append(Value::CreateStringValue(
+      child_ids->Append(base::StringValue::New(
           base::Int64ToString(*it)));
     }
   }
   return JsArgList(&return_args);
 }
 
 JsArgList SyncManager::SyncInternal::FindNodesContainingString(
     const JsArgList& args) {
   std::string query;
   ListValue return_args;
@@ skipping 11 matching lines @@
   return_args.Append(result);
 
   ReadTransaction trans(FROM_HERE, GetUserShare());
   std::vector<const syncable::EntryKernel*> entry_kernels;
   trans.GetLookup()->GetAllEntryKernels(trans.GetWrappedTrans(),
                                         &entry_kernels);
 
   for (std::vector<const syncable::EntryKernel*>::const_iterator it =
            entry_kernels.begin(); it != entry_kernels.end(); ++it) {
     if ((*it)->ContainsString(lowercase_query)) {
-      result->Append(new StringValue(base::Int64ToString(
+      result->Append(base::StringValue::New(base::Int64ToString(
           (*it)->ref(syncable::META_HANDLE))));
     }
   }
 
   return JsArgList(&return_args);
 }
 
 void SyncManager::SyncInternal::OnNotificationStateChange(
     bool notifications_enabled) {
   VLOG(1) << "P2P: Notifications enabled = "
           << (notifications_enabled ? "true" : "false");
   allstatus_.SetNotificationsEnabled(notifications_enabled);
   if (scheduler()) {
     scheduler()->set_notifications_enabled(notifications_enabled);
   }
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
-    details.Set("enabled", Value::CreateBooleanValue(notifications_enabled));
+    details.Set("enabled", base::BooleanValue::New(notifications_enabled));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManager::SyncInternal::UpdateNotificationInfo(
     const syncable::ModelTypePayloadMap& type_payloads) {
   for (syncable::ModelTypePayloadMap::const_iterator it = type_payloads.begin();
@@ skipping 21 matching lines @@
 
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
     details.Set("changedTypes", changed_types);
     for (syncable::ModelTypePayloadMap::const_iterator
              it = type_payloads.begin();
          it != type_payloads.end(); ++it) {
       const std::string& model_type_str =
           syncable::ModelTypeToString(it->first);
-      changed_types->Append(Value::CreateStringValue(model_type_str));
+      changed_types->Append(base::StringValue::New(model_type_str));
     }
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManager::SyncInternal::StoreState(
     const std::string& state) {
@@ skipping 131 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api