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

base/debug/trace_event_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.
 
 #include "base/debug/trace_event.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 202 matching lines @@
 
 bool TraceEventTestFixture::FindNonMatchingValue(const char* key,
                                                  const char* value) {
   JsonKeyValue key_values[] = {
     {key, value, IS_NOT_EQUAL},
     {0, 0, IS_EQUAL}
   };
   return FindMatchingTraceEntry(key_values);
 }
 
-bool IsStringInDict(const char* string_to_match, DictionaryValue* dict) {
+bool IsStringInDict(const char* string_to_match, const DictionaryValue* dict) {
   for (DictionaryValue::key_iterator ikey = dict->begin_keys();
        ikey != dict->end_keys(); ++ikey) {
-    Value* child = NULL;
+    const Value* child = NULL;
     if (!dict->GetWithoutPathExpansion(*ikey, &child))
       continue;
 
     if ((*ikey).find(string_to_match) != std::string::npos)
       return true;
 
     std::string value_str;
     child->GetAsString(&value_str);
     if (value_str.find(string_to_match) != std::string::npos)
       return true;
   }
 
   // Recurse to test arguments
-  DictionaryValue* args_dict = NULL;
+  const DictionaryValue* args_dict = NULL;
   dict->GetDictionary("args", &args_dict);
   if (args_dict)
     return IsStringInDict(string_to_match, args_dict);
 
   return false;
 }
 
-DictionaryValue* FindTraceEntry(const ListValue& trace_parsed,
-                                const char* string_to_match,
-                                DictionaryValue* match_after_this_item = NULL) {
+const DictionaryValue* FindTraceEntry(
+    const ListValue& trace_parsed,
+    const char* string_to_match,
+    const DictionaryValue* match_after_this_item = NULL) {
   // Scan all items
   size_t trace_parsed_count = trace_parsed.GetSize();
   for (size_t i = 0; i < trace_parsed_count; i++) {
-    Value* value = NULL;
+    const Value* value = NULL;
     trace_parsed.Get(i, &value);
     if (match_after_this_item) {
       if (value == match_after_this_item)
          match_after_this_item = NULL;
       continue;
     }
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
-    DictionaryValue* dict = static_cast<DictionaryValue*>(value);
+    const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
 
     if (IsStringInDict(string_to_match, dict))
       return dict;
   }
   return NULL;
 }
 
-std::vector<DictionaryValue*> FindTraceEntries(
+std::vector<const DictionaryValue*> FindTraceEntries(
     const ListValue& trace_parsed,
     const char* string_to_match) {
-  std::vector<DictionaryValue*> hits;
+  std::vector<const DictionaryValue*> hits;
   size_t trace_parsed_count = trace_parsed.GetSize();
   for (size_t i = 0; i < trace_parsed_count; i++) {
-    Value* value = NULL;
+    const Value* value = NULL;
     trace_parsed.Get(i, &value);
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
-    DictionaryValue* dict = static_cast<DictionaryValue*>(value);
+    const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
 
     if (IsStringInDict(string_to_match, dict))
       hits.push_back(dict);
   }
   return hits;
 }
 
 void TraceWithAllMacroVariants(WaitableEvent* task_complete_event) {
   {
     TRACE_EVENT_BEGIN_ETW("TRACE_EVENT_BEGIN_ETW call", 0x1122, "extrastring1");
@@ skipping 66 matching lines @@
     TRACE_COUNTER_ID1("all", "TRACE_COUNTER_ID1 call", 0x319009, 31415);
     TRACE_COUNTER_ID2("all", "TRACE_COUNTER_ID2 call", 0x319009,
                       "a", 30000, "b", 1415);
   } // Scope close causes TRACE_EVENT0 etc to send their END events.
 
   if (task_complete_event)
     task_complete_event->Signal();
 }
 
 void ValidateAllTraceMacrosCreatedData(const ListValue& trace_parsed) {
-  DictionaryValue* item = NULL;
+  const DictionaryValue* item = NULL;
 
 #define EXPECT_FIND_(string) \
     EXPECT_TRUE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_NOT_FIND_(string) \
     EXPECT_FALSE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_SUB_FIND_(string) \
     if (item) EXPECT_TRUE((IsStringInDict(string, item)));
 
   EXPECT_FIND_("ETW Trace Event");
   EXPECT_FIND_("all");
@@ skipping 212 matching lines @@
     task_complete_event->Signal();
 }
 
 void ValidateInstantEventPresentOnEveryThread(const ListValue& trace_parsed,
                                               int num_threads,
                                               int num_events) {
   std::map<int, std::map<int, bool> > results;
 
   size_t trace_parsed_count = trace_parsed.GetSize();
   for (size_t i = 0; i < trace_parsed_count; i++) {
-    Value* value = NULL;
+    const Value* value = NULL;
     trace_parsed.Get(i, &value);
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
-    DictionaryValue* dict = static_cast<DictionaryValue*>(value);
+    const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
     std::string name;
     dict->GetString("name", &name);
     if (name != "multi thread event")
       continue;
 
     int thread = 0;
     int event = 0;
     EXPECT_TRUE(dict->GetInteger("args.thread", &thread));
     EXPECT_TRUE(dict->GetInteger("args.event", &event));
     results[thread][event] = true;
@@ skipping 526 matching lines @@
   for (int i = 0; i < num_threads; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
   TraceLog::GetInstance()->SetEnabled(false);
 
   std::string tmp;
   int tmp_int;
-  DictionaryValue* item;
+  const DictionaryValue* item;
 
   // Make sure we get thread name metadata.
   // Note, the test suite may have created a ton of threads.
   // So, we'll have thread names for threads we didn't create.
-  std::vector<DictionaryValue*> items =
+  std::vector<const DictionaryValue*> items =
       FindTraceEntries(trace_parsed_, "thread_name");
   for (int i = 0; i < static_cast<int>(items.size()); i++) {
     item = items[i];
     ASSERT_TRUE(item);
     EXPECT_TRUE(item->GetInteger("tid", &tmp_int));
 
     // See if this thread name is one of the threads we just created
     for (int j = 0; j < num_threads; j++) {
       if(static_cast<int>(thread_ids[j]) != tmp_int)
         continue;
@@ skipping 26 matching lines @@
 
   PlatformThread::SetName("pub");
   TRACE_EVENT_INSTANT0("drink", "beer");
   TRACE_EVENT_INSTANT0("drink", "wine");
 
   PlatformThread::SetName(" bar");
   TRACE_EVENT_INSTANT0("drink", "whisky");
 
   TraceLog::GetInstance()->SetEnabled(false);
 
-  std::vector<DictionaryValue*> items =
+  std::vector<const DictionaryValue*> items =
       FindTraceEntries(trace_parsed_, "thread_name");
   EXPECT_EQ(1u, items.size());
   ASSERT_GT(items.size(), 0u);
-  DictionaryValue* item = items[0];
+  const DictionaryValue* item = items[0];
   ASSERT_TRUE(item);
   int tid;
   EXPECT_TRUE(item->GetInteger("tid", &tid));
   EXPECT_EQ(PlatformThread::CurrentId(), static_cast<PlatformThreadId>(tid));
 
   std::string expected_name = "cafe,pub, bar";
   std::string tmp;
   EXPECT_TRUE(item->GetString("args.name", &tmp));
   EXPECT_EQ(expected_name, tmp);
 }
@@ skipping 24 matching lines @@
       TRACE_EVENT_INSTANT0("all", "is recorded 1; system has been enabled");
       // Trace calls that will cache pointers to categories; they're valid here
       TraceCallsWithCachedCategoryPointersPointers(
           "is recorded 2; system has been enabled");
 
       TraceLog::GetInstance()->SetEnabled(false);
     } // scope to destroy singleton
     ASSERT_FALSE(TraceLog::GetInstance());
 
     // Now that singleton is destroyed, check what trace events were recorded
-    DictionaryValue* item = NULL;
+    const DictionaryValue* item = NULL;
     ListValue& trace_parsed = trace_parsed_;
     EXPECT_FIND_("is recorded 1");
     EXPECT_FIND_("is recorded 2");
     EXPECT_NOT_FIND_("not recorded");
 
     // Make additional trace event calls on the shutdown system. They should
     // all pass cleanly, but the data not be recorded. We'll verify that next
     // time around the loop (the only way to flush the trace buffers).
     TRACE_EVENT_BEGIN_ETW("not recorded; system shutdown", 0, NULL);
     TRACE_EVENT_END_ETW("not recorded; system shutdown", 0, NULL);
@@ skipping 59 matching lines @@
 
   // As per NormallyNoDeepCopy, modify the strings in place.
   name1[0] = name2[0] = name3[0] = arg1[0] = arg2[0] = val1[0] = val2[0] = '@';
 
   TraceLog::GetInstance()->SetEnabled(false);
 
   EXPECT_FALSE(FindTraceEntry(trace_parsed_, name1.c_str()));
   EXPECT_FALSE(FindTraceEntry(trace_parsed_, name2.c_str()));
   EXPECT_FALSE(FindTraceEntry(trace_parsed_, name3.c_str()));
 
-  DictionaryValue* entry1 = FindTraceEntry(trace_parsed_, kOriginalName1);
-  DictionaryValue* entry2 = FindTraceEntry(trace_parsed_, kOriginalName2);
-  DictionaryValue* entry3 = FindTraceEntry(trace_parsed_, kOriginalName3);
+  const DictionaryValue* entry1 = FindTraceEntry(trace_parsed_, kOriginalName1);
+  const DictionaryValue* entry2 = FindTraceEntry(trace_parsed_, kOriginalName2);
+  const DictionaryValue* entry3 = FindTraceEntry(trace_parsed_, kOriginalName3);
   ASSERT_TRUE(entry1);
   ASSERT_TRUE(entry2);
   ASSERT_TRUE(entry3);
 
   int i;
   EXPECT_FALSE(entry2->GetInteger("args.@rg1", &i));
   EXPECT_TRUE(entry2->GetInteger("args.arg1", &i));
   EXPECT_EQ(5, i);
 
   std::string s;
@@ skipping 20 matching lines @@
   Clear();
 
   trace_buffer_.Start();
   trace_buffer_.AddFragment("bla1,bla2,bla3,bla4");
   trace_buffer_.Finish();
   EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
 }
 
 }  // namespace debug
 }  // namespace base