Update from chromium a8e7c94b1b79a0948d05a1fcfff53391d22ce37a

net/base/trace_net_log_observer_unittest.cc

 // Copyright 2014 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 "net/base/trace_net_log_observer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_impl.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/base/capturing_net_log.h"
 #include "net/base/net_log.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::debug::TraceLog;
 
 namespace net {
 
 namespace {
 
+// TraceLog category for NetLog events.
+const char kNetLogTracingCategory[] = TRACE_DISABLED_BY_DEFAULT("netlog");
+
 struct TraceEntryInfo {
   std::string category;
   std::string id;
   std::string phase;
   std::string name;
   std::string source_type;
 };
 
 TraceEntryInfo GetTraceEntryInfoFromValue(const base::DictionaryValue& value) {
   TraceEntryInfo info;
@@ skipping 39 matching lines @@
     base::ListValue* trace_events = NULL;
     ASSERT_TRUE(trace_value->GetAsList(&trace_events));
 
     trace_events_ = FilterNetLogTraceEvents(*trace_events);
 
     if (!has_more_events)
       run_loop->Quit();
   }
 
   static void EnableTraceLog() {
-    TraceLog::GetInstance()->SetEnabled(base::debug::CategoryFilter("netlog"),
-                                        TraceLog::RECORDING_MODE,
-                                        base::debug::TraceOptions());
+    TraceLog::GetInstance()->SetEnabled(
+        base::debug::CategoryFilter(kNetLogTracingCategory),
+        TraceLog::RECORDING_MODE,
+        base::debug::TraceOptions());
   }
 
   void EndTraceAndFlush() {
     base::RunLoop run_loop;
     TraceLog::GetInstance()->SetDisabled();
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceNetLogObserverTest::OnTraceDataCollected,
                    base::Unretained(this),
                    base::Unretained(&run_loop)));
     run_loop.Run();
@@ skipping 11 matching lines @@
       if (!trace_events.GetDictionary(i, &dict)) {
         ADD_FAILURE() << "Unexpected non-dictionary event in trace_events";
         continue;
       }
       std::string category;
       if (!dict->GetString("cat", &category)) {
         ADD_FAILURE()
             << "Unexpected item without a category field in trace_events";
         continue;
       }
-      if (category != "netlog")
+      if (category != kNetLogTracingCategory)
         continue;
       filtered_trace_events->Append(dict->DeepCopy());
     }
     return filtered_trace_events.Pass();
   }
 
   base::ListValue* trace_events() const {
     return trace_events_.get();
   }
 
@@ skipping 44 matching lines @@
   const base::DictionaryValue* item1 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(0, &item1));
   const base::DictionaryValue* item2 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(1, &item2));
   const base::DictionaryValue* item3 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(2, &item3));
 
   TraceEntryInfo actual_item1 = GetTraceEntryInfoFromValue(*item1);
   TraceEntryInfo actual_item2 = GetTraceEntryInfoFromValue(*item2);
   TraceEntryInfo actual_item3 = GetTraceEntryInfoFromValue(*item3);
-  EXPECT_EQ("netlog", actual_item1.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item1.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[0].source.id), actual_item1.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item1.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_CANCELLED),
             actual_item1.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[0].source.type),
             actual_item1.source_type);
 
-  EXPECT_EQ("netlog", actual_item2.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item2.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[1].source.id), actual_item2.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN),
             actual_item2.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_URL_REQUEST_START_JOB),
             actual_item2.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[1].source.type),
             actual_item2.source_type);
 
-  EXPECT_EQ("netlog", actual_item3.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item3.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[2].source.id), actual_item3.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_END),
             actual_item3.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_REQUEST_ALIVE),
             actual_item3.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[2].source.type),
             actual_item3.source_type);
 }
 
 TEST_F(TraceNetLogObserverTest, EnableAndDisableTracing) {
@@ skipping 12 matching lines @@
   net_log()->GetEntries(&entries);
   EXPECT_EQ(3u, entries.size());
   EXPECT_EQ(2u, trace_events()->GetSize());
   const base::DictionaryValue* item1 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(0, &item1));
   const base::DictionaryValue* item2 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(1, &item2));
 
   TraceEntryInfo actual_item1 = GetTraceEntryInfoFromValue(*item1);
   TraceEntryInfo actual_item2 = GetTraceEntryInfoFromValue(*item2);
-  EXPECT_EQ("netlog", actual_item1.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item1.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[0].source.id), actual_item1.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item1.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_CANCELLED),
             actual_item1.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[0].source.type),
             actual_item1.source_type);
 
-  EXPECT_EQ("netlog", actual_item2.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item2.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[2].source.id), actual_item2.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item2.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_URL_REQUEST_START_JOB),
             actual_item2.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[2].source.type),
             actual_item2.source_type);
 }
 
 TEST_F(TraceNetLogObserverTest, DestroyObserverWhileTracing) {
   trace_net_log_observer()->WatchForTraceStart(net_log());
   EnableTraceLog();
   net_log()->AddGlobalEntry(NetLog::TYPE_CANCELLED);
   trace_net_log_observer()->StopWatchForTraceStart();
   set_trace_net_log_observer(NULL);
   net_log()->AddGlobalEntry(NetLog::TYPE_REQUEST_ALIVE);
 
   EndTraceAndFlush();
 
   CapturingNetLog::CapturedEntryList entries;
   net_log()->GetEntries(&entries);
   EXPECT_EQ(2u, entries.size());
   EXPECT_EQ(1u, trace_events()->GetSize());
 
   const base::DictionaryValue* item1 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(0, &item1));
 
   TraceEntryInfo actual_item1 = GetTraceEntryInfoFromValue(*item1);
-  EXPECT_EQ("netlog", actual_item1.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item1.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[0].source.id), actual_item1.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item1.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_CANCELLED),
             actual_item1.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[0].source.type),
             actual_item1.source_type);
 }
 
 TEST_F(TraceNetLogObserverTest, DestroyObserverWhileNotTracing) {
@@ skipping 47 matching lines @@
   net_log()->GetEntries(&entries);
   EXPECT_EQ(2u, entries.size());
   EXPECT_EQ(2u, trace_events()->GetSize());
   const base::DictionaryValue* item1 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(0, &item1));
   const base::DictionaryValue* item2 = NULL;
   ASSERT_TRUE(trace_events()->GetDictionary(1, &item2));
 
   TraceEntryInfo actual_item1 = GetTraceEntryInfoFromValue(*item1);
   TraceEntryInfo actual_item2 = GetTraceEntryInfoFromValue(*item2);
-  EXPECT_EQ("netlog", actual_item1.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item1.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[0].source.id), actual_item1.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item1.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_CANCELLED),
             actual_item1.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[0].source.type),
             actual_item1.source_type);
 
-  EXPECT_EQ("netlog", actual_item2.category);
+  EXPECT_EQ(kNetLogTracingCategory, actual_item2.category);
   EXPECT_EQ(base::StringPrintf("0x%d", entries[1].source.id), actual_item2.id);
   EXPECT_EQ(std::string(1, TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT),
             actual_item2.phase);
   EXPECT_EQ(NetLog::EventTypeToString(NetLog::TYPE_REQUEST_ALIVE),
             actual_item2.name);
   EXPECT_EQ(NetLog::SourceTypeToString(entries[1].source.type),
             actual_item2.source_type);
 
   std::string item1_params;
   std::string item2_params;
   EXPECT_TRUE(item1->GetString("args.params.foo", &item1_params));
   EXPECT_EQ("bar", item1_params);
 
   EXPECT_TRUE(item2->GetString("args.params", &item2_params));
   EXPECT_TRUE(item2_params.empty());
 }
 
 }  // namespace
 
 }  // namespace net