Correct const accessors in base/values.(h|cc), Part II (ListValue)

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright (c) 2012 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 982 matching lines @@
 
   JsArgList return_args;
 
   EXPECT_CALL(reply_handler,
               HandleJsReply("getRootNodeDetails", _))
       .WillOnce(SaveArg<1>(&return_args));
 
   SendJsMessage("getRootNodeDetails", kNoArgs, reply_handler.AsWeakHandle());
 
   EXPECT_EQ(1u, return_args.Get().GetSize());
-  DictionaryValue* node_info = NULL;
+  const DictionaryValue* node_info = NULL;
   EXPECT_TRUE(return_args.Get().GetDictionary(0, &node_info));
   if (node_info) {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode node(&trans);
     node.InitByRootLookup();
     CheckNodeValue(node, *node_info, true);
   } else {
     ADD_FAILURE();
   }
 }
 
 void CheckGetNodesByIdReturnArgs(SyncManager* sync_manager,
                                  const JsArgList& return_args,
                                  int64 id,
                                  bool is_detailed) {
   EXPECT_EQ(1u, return_args.Get().GetSize());
-  ListValue* nodes = NULL;
+  const ListValue* nodes = NULL;
   ASSERT_TRUE(return_args.Get().GetList(0, &nodes));
   ASSERT_TRUE(nodes);
   EXPECT_EQ(1u, nodes->GetSize());
-  DictionaryValue* node_info = NULL;
+  const DictionaryValue* node_info = NULL;
   EXPECT_TRUE(nodes->GetDictionary(0, &node_info));
   ASSERT_TRUE(node_info);
   ReadTransaction trans(FROM_HERE, sync_manager->GetUserShare());
   ReadNode node(&trans);
   EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
   CheckNodeValue(node, *node_info, is_detailed);
 }
 
 class SyncManagerGetNodesByIdTest : public SyncManagerTest {
  protected:
@@ skipping 122 matching lines @@
       .Times(1).WillRepeatedly(SaveArg<1>(&return_args));
 
   {
     ListValue args;
     args.Append(Value::CreateStringValue("1"));
     SendJsMessage("getChildNodeIds",
                   JsArgList(&args), reply_handler.AsWeakHandle());
   }
 
   EXPECT_EQ(1u, return_args.Get().GetSize());
-  ListValue* nodes = NULL;
+  const ListValue* nodes = NULL;
   ASSERT_TRUE(return_args.Get().GetList(0, &nodes));
   ASSERT_TRUE(nodes);
   EXPECT_EQ(6u, nodes->GetSize());
 }
 
 TEST_F(SyncManagerTest, GetChildNodeIdsFailure) {
   StrictMock<MockJsReplyHandler> reply_handler;
 
   ListValue empty_list_args;
   empty_list_args.Append(new ListValue());
@@ skipping 53 matching lines @@
   }
 
   // There's not much value in verifying every attribute on every node here.
   // Most of the value of this test has already been achieved: we've verified we
   // can call the above function without crashing or leaking memory.
   //
   // Let's just check the list size and a few of its elements.  Anything more
   // would make this test brittle without greatly increasing our chances of
   // catching real bugs.
 
-  ListValue* node_list;
-  DictionaryValue* first_result;
+  const ListValue* node_list;
+  const DictionaryValue* first_result;
 
   // The resulting argument list should have one argument, a list of nodes.
   ASSERT_EQ(1U, return_args.Get().GetSize());
   ASSERT_TRUE(return_args.Get().GetList(0, &node_list));
 
   // The database creation logic depends on the routing info.
   // Refer to setup methods for more information.
   ModelSafeRoutingInfo routes;
   GetModelSafeRoutingInfo(&routes);
   size_t directory_size = routes.size() + 1;
@@ skipping 1529 matching lines @@
 
   // Verify only the non-disabled types remain after cleanup.
   sync_manager_.PurgeDisabledTypes(enabled_types, new_enabled_types);
   EXPECT_TRUE(new_enabled_types.Equals(
       Union(sync_manager_.InitialSyncEndedTypes(), partial_enabled_types)));
   EXPECT_TRUE(disabled_types.Equals(
       sync_manager_.GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All())));
 }
 
 }  // namespace