more changes

chrome/browser/sync/engine/syncapi_unittest.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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 900 matching lines @@
   sync_manager_.UpdateEnabledTypes();
   EXPECT_EQ(2, update_enabled_types_call_count_);
 }
 
 TEST_F(SyncManagerTest, ProcessJsMessage) {
   const JsArgList kNoArgs;
 
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue false_args;
-  false_args.Append(Value::CreateBooleanValue(false));
+  false_args.Append(base::FalseValue());
 
   EXPECT_CALL(reply_handler,
               HandleJsReply("getNotificationState",
                             HasArgsAsList(false_args)));
 
   // This message should be dropped.
   SendJsMessage("unknownMessage", kNoArgs, reply_handler.AsWeakHandle());
 
   SendJsMessage("getNotificationState", kNoArgs, reply_handler.AsWeakHandle());
 }
@@ skipping 66 matching lines @@
     const int64 ids[] = { root_id, child_id };
 
     EXPECT_CALL(reply_handler,
                 HandleJsReply(message_name, _))
         .Times(arraysize(ids)).WillRepeatedly(SaveArg<1>(&return_args));
 
     for (size_t i = 0; i < arraysize(ids); ++i) {
       ListValue args;
       ListValue* id_values = new ListValue();
       args.Append(id_values);
-      id_values->Append(Value::CreateStringValue(base::Int64ToString(ids[i])));
+      id_values->Append(base::StringValue::New(base::Int64ToString(ids[i])));
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
 
       CheckGetNodesByIdReturnArgs(sync_manager_, return_args,
                                   ids[i], is_detailed);
     }
   }
 
   void RunGetNodesByIdFailureTest(const char* message_name) {
     StrictMock<MockJsReplyHandler> reply_handler;
@@ skipping 16 matching lines @@
       ListValue args;
       args.Append(new ListValue());
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
     }
 
     {
       ListValue args;
       ListValue* ids = new ListValue();
       args.Append(ids);
-      ids->Append(Value::CreateStringValue(""));
+      ids->Append(base::StringValue::New(""));
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
     }
 
     {
       ListValue args;
       ListValue* ids = new ListValue();
       args.Append(ids);
-      ids->Append(Value::CreateStringValue("nonsense"));
+      ids->Append(base::StringValue::New("nonsense"));
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
     }
 
     {
       ListValue args;
       ListValue* ids = new ListValue();
       args.Append(ids);
-      ids->Append(Value::CreateStringValue("0"));
+      ids->Append(base::StringValue::New("0"));
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
     }
 
     {
       ListValue args;
       ListValue* ids = new ListValue();
       args.Append(ids);
-      ids->Append(Value::CreateStringValue("9999"));
+      ids->Append(base::StringValue::New("9999"));
       SendJsMessage(message_name,
                     JsArgList(&args), reply_handler.AsWeakHandle());
     }
   }
 };
 
 TEST_F(SyncManagerGetNodesByIdTest, GetNodeSummariesById) {
   RunGetNodesByIdTest("getNodeSummariesById", false);
 }
 
@@ skipping 13 matching lines @@
   StrictMock<MockJsReplyHandler> reply_handler;
 
   JsArgList return_args;
 
   EXPECT_CALL(reply_handler,
               HandleJsReply("getChildNodeIds", _))
       .Times(1).WillRepeatedly(SaveArg<1>(&return_args));
 
   {
     ListValue args;
-    args.Append(Value::CreateStringValue("1"));
+    args.Append(base::StringValue::New("1"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   EXPECT_EQ(1u, return_args.Get().GetSize());
   ListValue* nodes = NULL;
   ASSERT_TRUE(return_args.Get().GetList(0, &nodes));
   ASSERT_TRUE(nodes);
   EXPECT_EQ(5u, nodes->GetSize());
 }
@@ skipping 10 matching lines @@
       .Times(5);
 
   {
     ListValue args;
     SendJsMessage("getChildNodeIds",
                    JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   {
     ListValue args;
-    args.Append(Value::CreateStringValue(""));
+    args.Append(base::StringValue::New(""));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   {
     ListValue args;
-    args.Append(Value::CreateStringValue("nonsense"));
+    args.Append(base::StringValue::New("nonsense"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   {
     ListValue args;
-    args.Append(Value::CreateStringValue("0"));
+    args.Append(base::StringValue::New("0"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   {
     ListValue args;
-    args.Append(Value::CreateStringValue("9999"));
+    args.Append(base::StringValue::New("9999"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 }
 
 // TODO(akalin): Add unit tests for findNodesContainingString message.
 
 TEST_F(SyncManagerTest, OnNotificationStateChange) {
   InSequence dummy;
   StrictMock<MockJsEventHandler> event_handler;
@@ skipping 36 matching lines @@
   // Build expected_args to have a single argument with the string
   // equivalents of model_types.
   DictionaryValue expected_details;
   {
     ListValue* model_type_list = new ListValue();
     expected_details.Set("changedTypes", model_type_list);
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
       if (model_types[i]) {
         model_type_list->Append(
-            Value::CreateStringValue(
+            base::StringValue::New(
                 syncable::ModelTypeToString(
                     syncable::ModelTypeFromInt(i))));
       }
     }
   }
 
   EXPECT_CALL(event_handler,
               HandleJsEvent("onIncomingNotification",
                            HasDetailsAsDictionary(expected_details)));
 
@@ skipping 197 matching lines @@
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode password_node(&trans);
     EXPECT_FALSE(password_node.InitByIdLookup(node_id));
   }
 }
 
 }  // namespace
 
 }  // namespace browser_sync