Cleanup: Better constify some strings in base.

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_unittest.h"
 
 #include <math.h>
 #include <cstdlib>
 
 #include "base/bind.h"
@@ skipping 234 matching lines @@
       continue;
     DictionaryValue* dict = static_cast<DictionaryValue*>(value);
 
     if (IsAllKeyValueInDict(key_values, dict))
       return dict;
   }
   return NULL;
 }
 
 void TraceEventTestFixture::DropTracedMetadataRecords() {
-
   scoped_ptr<ListValue> old_trace_parsed(trace_parsed_.DeepCopy());
   size_t old_trace_parsed_size = old_trace_parsed->GetSize();
   trace_parsed_.Clear();
 
   for (size_t i = 0; i < old_trace_parsed_size; i++) {
     Value* value = NULL;
     old_trace_parsed->Get(i, &value);
     if (!value || value->GetType() != Value::TYPE_DICTIONARY) {
       trace_parsed_.Append(value->DeepCopy());
       continue;
     }
     DictionaryValue* dict = static_cast<DictionaryValue*>(value);
     std::string tmp;
-    if(dict->GetString("ph", &tmp) && tmp == "M")
+    if (dict->GetString("ph", &tmp) && tmp == "M")
       continue;
 
     trace_parsed_.Append(value->DeepCopy());
   }
 }
 
 DictionaryValue* TraceEventTestFixture::FindNamePhase(const char* name,
                                                       const char* phase) {
   JsonKeyValue key_values[] = {
     {"name", name, IS_EQUAL},
@@ skipping 90 matching lines @@
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
 
     if (IsStringInDict(string_to_match, dict))
       hits.push_back(dict);
   }
   return hits;
 }
 
-const char* kControlCharacters = "\001\002\003\n\r";
+const char kControlCharacters[] = "\001\002\003\n\r";
 
 void TraceWithAllMacroVariants(WaitableEvent* task_complete_event) {
   {
     TRACE_EVENT_BEGIN_ETW("TRACE_EVENT_BEGIN_ETW call", 0x1122, "extrastring1");
     TRACE_EVENT_END_ETW("TRACE_EVENT_END_ETW call", 0x3344, "extrastring2");
     TRACE_EVENT_INSTANT_ETW("TRACE_EVENT_INSTANT_ETW call",
                             0x5566, "extrastring3");
 
     TRACE_EVENT0("all", "TRACE_EVENT0 call");
     TRACE_EVENT1("all", "TRACE_EVENT1 call", "name1", "value1");
@@ skipping 80 matching lines @@
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
         "all", "tracked object 1", 0x42, "hello");
     TRACE_EVENT_OBJECT_DELETED_WITH_ID("all", "tracked object 1", 0x42);
 
     TraceScopedTrackableObject<int> trackable("all", "tracked object 2",
                                               0x2128506);
     trackable.snapshot("world");
 
     TRACE_EVENT1(kControlCharacters, kControlCharacters,
                  kControlCharacters, kControlCharacters);
-  } // Scope close causes TRACE_EVENT0 etc to send their END events.
+  }  // 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) {
   const DictionaryValue* item = NULL;
 
 #define EXPECT_FIND_(string) \
     item = FindTraceEntry(trace_parsed, string); \
@@ skipping 801 matching lines @@
   TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 0);
 }
 
 // Test ASYNC_BEGIN/END events
 TEST_F(TraceEventTestFixture, AsyncBeginEndEvents) {
   BeginTrace();
 
   unsigned long long id = 0xfeedbeeffeedbeefull;
-  TRACE_EVENT_ASYNC_BEGIN0( "cat", "name1", id);
-  TRACE_EVENT_ASYNC_STEP_INTO0( "cat", "name1", id, "step1");
+  TRACE_EVENT_ASYNC_BEGIN0("cat", "name1", id);
+  TRACE_EVENT_ASYNC_STEP_INTO0("cat", "name1", id, "step1");
   TRACE_EVENT_ASYNC_END0("cat", "name1", id);
-  TRACE_EVENT_BEGIN0( "cat", "name2");
-  TRACE_EVENT_ASYNC_BEGIN0( "cat", "name3", 0);
-  TRACE_EVENT_ASYNC_STEP_PAST0( "cat", "name3", 0, "step2");
+  TRACE_EVENT_BEGIN0("cat", "name2");
+  TRACE_EVENT_ASYNC_BEGIN0("cat", "name3", 0);
+  TRACE_EVENT_ASYNC_STEP_PAST0("cat", "name3", 0, "step2");
 
   EndTraceAndFlush();
 
   EXPECT_TRUE(FindNamePhase("name1", "S"));
   EXPECT_TRUE(FindNamePhase("name1", "T"));
   EXPECT_TRUE(FindNamePhase("name1", "F"));
 
   std::string id_str;
   StringAppendF(&id_str, "0x%llx", id);
 
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "S", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "T", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "F", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name3", "S", "id", "0x0"));
   EXPECT_TRUE(FindNamePhaseKeyValue("name3", "p", "id", "0x0"));
 
   // BEGIN events should not have id
   EXPECT_FALSE(FindNamePhaseKeyValue("name2", "B", "id", "0"));
 }
 
 // Test ASYNC_BEGIN/END events
 TEST_F(TraceEventTestFixture, AsyncBeginEndPointerMangling) {
   void* ptr = this;
 
   TraceLog::GetInstance()->SetProcessID(100);
   BeginTrace();
-  TRACE_EVENT_ASYNC_BEGIN0( "cat", "name1", ptr);
-  TRACE_EVENT_ASYNC_BEGIN0( "cat", "name2", ptr);
+  TRACE_EVENT_ASYNC_BEGIN0("cat", "name1", ptr);
+  TRACE_EVENT_ASYNC_BEGIN0("cat", "name2", ptr);
   EndTraceAndFlush();
 
   TraceLog::GetInstance()->SetProcessID(200);
   BeginTrace();
-  TRACE_EVENT_ASYNC_END0( "cat", "name1", ptr);
+  TRACE_EVENT_ASYNC_END0("cat", "name1", ptr);
   EndTraceAndFlush();
 
   DictionaryValue* async_begin = FindNamePhase("name1", "S");
   DictionaryValue* async_begin2 = FindNamePhase("name2", "S");
   DictionaryValue* async_end = FindNamePhase("name1", "F");
   EXPECT_TRUE(async_begin);
   EXPECT_TRUE(async_begin2);
   EXPECT_TRUE(async_end);
 
   Value* value = NULL;
@@ skipping 131 matching lines @@
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 }
 
 // Test that thread and process names show up in the trace
 TEST_F(TraceEventTestFixture, ThreadNames) {
   // Create threads before we enable tracing to make sure
   // that tracelog still captures them.
-  const int num_threads = 4;
-  const int num_events = 10;
-  Thread* threads[num_threads];
-  PlatformThreadId thread_ids[num_threads];
-  for (int i = 0; i < num_threads; i++)
+  const int kNumThreads = 4;
+  const int kNumEvents = 10;
+  Thread* threads[kNumThreads];
+  PlatformThreadId thread_ids[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++)
     threads[i] = new Thread(StringPrintf("Thread %d", i));
 
   // Enable tracing.
   BeginTrace();
 
   // Now run some trace code on these threads.
-  WaitableEvent* task_complete_events[num_threads];
-  for (int i = 0; i < num_threads; i++) {
+  WaitableEvent* task_complete_events[kNumThreads];
+  for (int i = 0; i < kNumThreads; i++) {
     task_complete_events[i] = new WaitableEvent(false, false);
     threads[i]->Start();
     thread_ids[i] = threads[i]->thread_id();
     threads[i]->message_loop()->PostTask(
         FROM_HERE, base::Bind(&TraceManyInstantEvents,
-                              i, num_events, task_complete_events[i]));
+                              i, kNumEvents, task_complete_events[i]));
   }
-  for (int i = 0; i < num_threads; i++) {
+  for (int i = 0; i < kNumThreads; i++) {
     task_complete_events[i]->Wait();
   }
 
   // Shut things down.
-  for (int i = 0; i < num_threads; i++) {
+  for (int i = 0; i < kNumThreads; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
   EndTraceAndFlush();
 
   std::string tmp;
   int tmp_int;
   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<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++) {
+    for (int j = 0; j < kNumThreads; j++) {
       if(static_cast<int>(thread_ids[j]) != tmp_int)
         continue;
 
       std::string expected_name = StringPrintf("Thread %d", j);
       EXPECT_TRUE(item->GetString("ph", &tmp) && tmp == "M");
       EXPECT_TRUE(item->GetInteger("pid", &tmp_int) &&
                   tmp_int == static_cast<int>(base::GetCurrentProcId()));
       // If the thread name changes or the tid gets reused, the name will be
       // a comma-separated list of thread names, so look for a substring.
       EXPECT_TRUE(item->GetString("args.name", &tmp) &&
@@ skipping 1410 matching lines @@
   {
     TRACE_EVENT_SYNTHETIC_DELAY("test.Delay");
   }
   base::TimeDelta duration = base::TimeTicks::Now() - start;
   EXPECT_GE(duration.InMilliseconds(), 50);
 
   EndTraceAndFlush();
 }
 
 TEST_F(TraceEventTestFixture, BadSyntheticDelayConfigurations) {
-  const char* configs[] = {
+  const char* const configs[] = {
     "",
     "DELAY(",
     "DELAY(;",
     "DELAY(;)",
     "DELAY(test.Delay)",
     "DELAY(test.Delay;)"
   };
   for (size_t i = 0; i < arraysize(configs); i++) {
     BeginSpecificTrace(configs[i]);
     EndTraceAndFlush();
@@ skipping 89 matching lines @@
         EXPECT_EQ(original_option.enable_sampling, new_options.enable_sampling);
         EXPECT_EQ(original_option.enable_systrace, new_options.enable_systrace);
       }
     }
   }
 }
 
 
 }  // namespace debug
 }  // namespace base