Add a |scope| argument to TRACE_EVENT_INSTANT* and require its presence.

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 <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 308 matching lines @@
     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");
     TRACE_EVENT2("all", "TRACE_EVENT2 call",
                  "name1", "\"value1\"",
                  "name2", "value\\2");
 
-    TRACE_EVENT_INSTANT0("all", "TRACE_EVENT_INSTANT0 call");
-    TRACE_EVENT_INSTANT1("all", "TRACE_EVENT_INSTANT1 call", "name1", "value1");
+    TRACE_EVENT_INSTANT0("all", "TRACE_EVENT_INSTANT0 call",
+                         TRACE_EVENT_SCOPE_GLOBAL);
+    TRACE_EVENT_INSTANT1("all", "TRACE_EVENT_INSTANT1 call",
+                         TRACE_EVENT_SCOPE_PROCESS, "name1", "value1");
     TRACE_EVENT_INSTANT2("all", "TRACE_EVENT_INSTANT2 call",
+                         TRACE_EVENT_SCOPE_THREAD,
                          "name1", "value1",
                          "name2", "value2");
 
     TRACE_EVENT_BEGIN0("all", "TRACE_EVENT_BEGIN0 call");
     TRACE_EVENT_BEGIN1("all", "TRACE_EVENT_BEGIN1 call", "name1", "value1");
     TRACE_EVENT_BEGIN2("all", "TRACE_EVENT_BEGIN2 call",
                        "name1", "value1",
                        "name2", "value2");
 
     TRACE_EVENT_END0("all", "TRACE_EVENT_END0 call");
@@ skipping 98 matching lines @@
   EXPECT_FIND_("TRACE_EVENT1 call");
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("value1");
   EXPECT_FIND_("TRACE_EVENT2 call");
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("\"value1\"");
   EXPECT_SUB_FIND_("name2");
   EXPECT_SUB_FIND_("value\\2");
 
   EXPECT_FIND_("TRACE_EVENT_INSTANT0 call");
+  {
+    std::string scope;
+    EXPECT_TRUE((item && item->GetString("s", &scope)));
+    EXPECT_EQ("g", scope);
+  }
   EXPECT_FIND_("TRACE_EVENT_INSTANT1 call");
+  {
+    std::string scope;
+    EXPECT_TRUE((item && item->GetString("s", &scope)));
+    EXPECT_EQ("p", scope);
+  }
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("value1");
   EXPECT_FIND_("TRACE_EVENT_INSTANT2 call");
+  {
+    std::string scope;
+    EXPECT_TRUE((item && item->GetString("s", &scope)));
+    EXPECT_EQ("t", scope);
+  }
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("value1");
   EXPECT_SUB_FIND_("name2");
   EXPECT_SUB_FIND_("value2");
 
   EXPECT_FIND_("TRACE_EVENT_BEGIN0 call");
   EXPECT_FIND_("TRACE_EVENT_BEGIN1 call");
   EXPECT_SUB_FIND_("name1");
   EXPECT_SUB_FIND_("value1");
   EXPECT_FIND_("TRACE_EVENT_BEGIN2 call");
@@ skipping 224 matching lines @@
     EXPECT_EQ("D", phase);
     EXPECT_TRUE((item && item->GetString("id", &id)));
     EXPECT_EQ("2128506", id);
   }
 }
 
 void TraceManyInstantEvents(int thread_id, int num_events,
                             WaitableEvent* task_complete_event) {
   for (int i = 0; i < num_events; i++) {
     TRACE_EVENT_INSTANT2("all", "multi thread event",
+                         TRACE_EVENT_SCOPE_THREAD,
                          "thread", thread_id,
                          "event", i);
   }
 
   if (task_complete_event)
     task_complete_event->Signal();
 }
 
 void ValidateInstantEventPresentOnEveryThread(const ListValue& trace_parsed,
                                               int num_threads,
@@ skipping 22 matching lines @@
   EXPECT_FALSE(results[-1][-1]);
   for (int thread = 0; thread < num_threads; thread++) {
     for (int event = 0; event < num_events; event++) {
       EXPECT_TRUE(results[thread][event]);
     }
   }
 }
 
 void TraceCallsWithCachedCategoryPointersPointers(const char* name_str) {
   TRACE_EVENT0("category name1", name_str);
-  TRACE_EVENT_INSTANT0("category name2", name_str);
+  TRACE_EVENT_INSTANT0("category name2", name_str, TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_BEGIN0("category name3", name_str);
   TRACE_EVENT_END0("category name4", name_str);
 }
 
 }  // namespace
 
 void HighResSleepForTraceTest(base::TimeDelta elapsed) {
   base::TimeTicks end_time = base::TimeTicks::HighResNow() + elapsed;
   do {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
@@ skipping 93 matching lines @@
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
 }
 
 // Test that categories work.
 TEST_F(TraceEventTestFixture, Categories) {
   ManualTestSetUp();
 
   // Test that categories that are used can be retrieved whether trace was
   // enabled or disabled when the trace event was encountered.
-  TRACE_EVENT_INSTANT0("c1", "name");
-  TRACE_EVENT_INSTANT0("c2", "name");
+  TRACE_EVENT_INSTANT0("c1", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("c2", "name", TRACE_EVENT_SCOPE_THREAD);
   BeginTrace();
-  TRACE_EVENT_INSTANT0("c3", "name");
-  TRACE_EVENT_INSTANT0("c4", "name");
+  TRACE_EVENT_INSTANT0("c3", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("c4", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   std::vector<std::string> cats;
   TraceLog::GetInstance()->GetKnownCategories(&cats);
   EXPECT_TRUE(std::find(cats.begin(), cats.end(), "c1") != cats.end());
   EXPECT_TRUE(std::find(cats.begin(), cats.end(), "c2") != cats.end());
   EXPECT_TRUE(std::find(cats.begin(), cats.end(), "c3") != cats.end());
   EXPECT_TRUE(std::find(cats.begin(), cats.end(), "c4") != cats.end());
 
   const std::vector<std::string> empty_categories;
   std::vector<std::string> included_categories;
   std::vector<std::string> excluded_categories;
 
   // Test that category filtering works.
 
   // Include nonexistent category -> no events
   Clear();
   included_categories.clear();
   included_categories.push_back("not_found823564786");
   TraceLog::GetInstance()->SetEnabled(included_categories, empty_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("cat1", "name");
-  TRACE_EVENT_INSTANT0("cat2", "name");
+  TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(trace_parsed_.empty());
 
   // Include existent category -> only events of that category
   Clear();
   included_categories.clear();
   included_categories.push_back("inc");
   TraceLog::GetInstance()->SetEnabled(included_categories, empty_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("inc", "name");
-  TRACE_EVENT_INSTANT0("inc2", "name");
+  TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc"));
   EXPECT_FALSE(FindNonMatchingValue("cat", "inc"));
 
   // Include existent wildcard -> all categories matching wildcard
   Clear();
   included_categories.clear();
   included_categories.push_back("inc_wildcard_*");
   included_categories.push_back("inc_wildchar_?_end");
   TraceLog::GetInstance()->SetEnabled(included_categories, empty_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included");
-  TRACE_EVENT_INSTANT0("inc_wildcard_", "included");
-  TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included");
-  TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc");
-  TRACE_EVENT_INSTANT0("cat1", "not_inc");
-  TRACE_EVENT_INSTANT0("cat2", "not_inc");
+  TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included",
+                       TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildcard_", "included", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included",
+                       TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc",
+                       TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat1", "not_inc", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat2", "not_inc", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_abc"));
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_"));
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_x_end"));
   EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
 
   included_categories.clear();
 
   // Exclude nonexistent category -> all events
   Clear();
   excluded_categories.clear();
   excluded_categories.push_back("not_found823564786");
   TraceLog::GetInstance()->SetEnabled(empty_categories, excluded_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("cat1", "name");
-  TRACE_EVENT_INSTANT0("cat2", "name");
+  TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
 
   // Exclude existent category -> only events of other categories
   Clear();
   excluded_categories.clear();
   excluded_categories.push_back("inc");
   TraceLog::GetInstance()->SetEnabled(empty_categories, excluded_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("inc", "name");
-  TRACE_EVENT_INSTANT0("inc2", "name");
+  TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc2"));
   EXPECT_FALSE(FindMatchingValue("cat", "inc"));
 
   // Exclude existent wildcard -> all categories not matching wildcard
   Clear();
   excluded_categories.clear();
   excluded_categories.push_back("inc_wildcard_*");
   excluded_categories.push_back("inc_wildchar_?_end");
   TraceLog::GetInstance()->SetEnabled(empty_categories, excluded_categories,
                                       TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc");
-  TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc");
-  TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc");
-  TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included");
-  TRACE_EVENT_INSTANT0("cat1", "included");
-  TRACE_EVENT_INSTANT0("cat2", "included");
+  TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc",
+                       TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included",
+                       TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat1", "included", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("cat2", "included", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_bla_end"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
   EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
 }
 
 
 // Test EVENT_WATCH_NOTIFICATION
 TEST_F(TraceEventTestFixture, EventWatchNotification) {
   ManualTestSetUp();
 
   // Basic one occurrence.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
-  TRACE_EVENT_INSTANT0("cat", "event");
+  TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 1);
 
   // Basic one occurrence before Set.
   BeginTrace();
-  TRACE_EVENT_INSTANT0("cat", "event");
+  TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 1);
 
   // Auto-reset after end trace.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   EndTraceAndFlush();
   BeginTrace();
-  TRACE_EVENT_INSTANT0("cat", "event");
+  TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 0);
 
   // Multiple occurrence.
   BeginTrace();
   int num_occurrences = 5;
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   for (int i = 0; i < num_occurrences; ++i)
-    TRACE_EVENT_INSTANT0("cat", "event");
+    TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, num_occurrences);
 
   // Wrong category.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
-  TRACE_EVENT_INSTANT0("wrong_cat", "event");
+  TRACE_EVENT_INSTANT0("wrong_cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 0);
 
   // Wrong name.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
-  TRACE_EVENT_INSTANT0("cat", "wrong_event");
+  TRACE_EVENT_INSTANT0("cat", "wrong_event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 0);
 
   // Canceled.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   TraceLog::GetInstance()->CancelWatchEvent();
-  TRACE_EVENT_INSTANT0("cat", "event");
+  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) {
   ManualTestSetUp();
   BeginTrace();
 
   unsigned long long id = 0xfeedbeeffeedbeefull;
@@ skipping 234 matching lines @@
     }
   }
 }
 
 TEST_F(TraceEventTestFixture, ThreadNameChanges) {
   ManualTestSetUp();
 
   BeginTrace();
 
   PlatformThread::SetName("");
-  TRACE_EVENT_INSTANT0("drink", "water");
+  TRACE_EVENT_INSTANT0("drink", "water", TRACE_EVENT_SCOPE_THREAD);
 
   PlatformThread::SetName("cafe");
-  TRACE_EVENT_INSTANT0("drink", "coffee");
+  TRACE_EVENT_INSTANT0("drink", "coffee", TRACE_EVENT_SCOPE_THREAD);
 
   PlatformThread::SetName("shop");
   // No event here, so won't appear in combined name.
 
   PlatformThread::SetName("pub");
-  TRACE_EVENT_INSTANT0("drink", "beer");
-  TRACE_EVENT_INSTANT0("drink", "wine");
+  TRACE_EVENT_INSTANT0("drink", "beer", TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("drink", "wine", TRACE_EVENT_SCOPE_THREAD);
 
   PlatformThread::SetName(" bar");
-  TRACE_EVENT_INSTANT0("drink", "whisky");
+  TRACE_EVENT_INSTANT0("drink", "whisky", TRACE_EVENT_SCOPE_THREAD);
 
   EndTraceAndFlush();
 
   std::vector<const DictionaryValue*> items =
       FindTraceEntries(trace_parsed_, "thread_name");
   EXPECT_EQ(1u, items.size());
   ASSERT_GT(items.size(), 0u);
   const DictionaryValue* item = items[0];
   ASSERT_TRUE(item);
   int tid;
@@ skipping 18 matching lines @@
   // recorded after the system is started again.
   for (int i = 0; i < 4; i++) {
     // Scope to contain the then destroy the TraceLog singleton.
     {
       base::ShadowingAtExitManager exit_manager_will_destroy_singletons;
 
       // Setup TraceLog singleton inside this test's exit manager scope
       // so that it will be destroyed when this scope closes.
       ManualTestSetUp();
 
-      TRACE_EVENT_INSTANT0("all", "not recorded; system not enabled");
+      TRACE_EVENT_INSTANT0("all", "not recorded; system not enabled",
+                           TRACE_EVENT_SCOPE_THREAD);
 
       BeginTrace();
 
-      TRACE_EVENT_INSTANT0("all", "is recorded 1; system has been enabled");
+      TRACE_EVENT_INSTANT0("all", "is recorded 1; system has been enabled",
+                           TRACE_EVENT_SCOPE_THREAD);
       // Trace calls that will cache pointers to categories; they're valid here
       TraceCallsWithCachedCategoryPointersPointers(
           "is recorded 2; system has been enabled");
 
       EndTraceAndFlush();
     } // scope to destroy singleton
     ASSERT_FALSE(TraceLog::GetInstance());
 
     // Now that singleton is destroyed, check what trace events were recorded
     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);
     TRACE_EVENT_INSTANT_ETW("not recorded; system shutdown", 0, NULL);
     TRACE_EVENT0("all", "not recorded; system shutdown");
-    TRACE_EVENT_INSTANT0("all", "not recorded; system shutdown");
+    TRACE_EVENT_INSTANT0("all", "not recorded; system shutdown",
+                         TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_BEGIN0("all", "not recorded; system shutdown");
     TRACE_EVENT_END0("all", "not recorded; system shutdown");
 
     TRACE_EVENT0("new category 0!", "not recorded; system shutdown");
-    TRACE_EVENT_INSTANT0("new category 1!", "not recorded; system shutdown");
+    TRACE_EVENT_INSTANT0("new category 1!", "not recorded; system shutdown",
+                         TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_BEGIN0("new category 2!", "not recorded; system shutdown");
     TRACE_EVENT_END0("new category 3!", "not recorded; system shutdown");
 
     // Cached categories should be safe to check, and still disable traces
     TraceCallsWithCachedCategoryPointersPointers(
         "not recorded; system shutdown");
   }
 }
 
 TEST_F(TraceEventTestFixture, NormallyNoDeepCopy) {
   // Test that the TRACE_EVENT macros do not deep-copy their string. If they
   // do so it may indicate a performance regression, but more-over it would
   // make the DEEP_COPY overloads redundant.
   ManualTestSetUp();
 
   std::string name_string("event name");
 
   BeginTrace();
-  TRACE_EVENT_INSTANT0("category", name_string.c_str());
+  TRACE_EVENT_INSTANT0("category", name_string.c_str(),
+                       TRACE_EVENT_SCOPE_THREAD);
 
   // Modify the string in place (a wholesale reassignment may leave the old
   // string intact on the heap).
   name_string[0] = '@';
 
   EndTraceAndFlush();
 
   EXPECT_FALSE(FindTraceEntry(trace_parsed_, "event name"));
   EXPECT_TRUE(FindTraceEntry(trace_parsed_, name_string.c_str()));
 }
 
 TEST_F(TraceEventTestFixture, DeepCopy) {
   ManualTestSetUp();
 
   static const char kOriginalName1[] = "name1";
   static const char kOriginalName2[] = "name2";
   static const char kOriginalName3[] = "name3";
   std::string name1(kOriginalName1);
   std::string name2(kOriginalName2);
   std::string name3(kOriginalName3);
   std::string arg1("arg1");
   std::string arg2("arg2");
   std::string val1("val1");
   std::string val2("val2");
 
   BeginTrace();
-  TRACE_EVENT_COPY_INSTANT0("category", name1.c_str());
+  TRACE_EVENT_COPY_INSTANT0("category", name1.c_str(),
+                            TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_COPY_BEGIN1("category", name2.c_str(),
                           arg1.c_str(), 5);
   TRACE_EVENT_COPY_END2("category", name3.c_str(),
                         arg1.c_str(), val1,
                         arg2.c_str(), val2);
 
   // As per NormallyNoDeepCopy, modify the strings in place.
   name1[0] = name2[0] = name3[0] = arg1[0] = arg2[0] = val1[0] = val2[0] = '@';
 
   EndTraceAndFlush();
@@ skipping 43 matching lines @@
   EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
 }
 
 // Test that trace_event parameters are not evaluated if the tracing
 // system is disabled.
 TEST_F(TraceEventTestFixture, TracingIsLazy) {
   ManualTestSetUp();
   BeginTrace();
 
   int a = 0;
-  TRACE_EVENT_INSTANT1("category", "test", "a", a++);
+  TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
   EXPECT_EQ(1, a);
 
   TraceLog::GetInstance()->SetDisabled();
 
-  TRACE_EVENT_INSTANT1("category", "test", "a", a++);
+  TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
   EXPECT_EQ(1, a);
 
   EndTraceAndFlush();
 }
 
 TEST_F(TraceEventTestFixture, TraceEnableDisable) {
   ManualTestSetUp();
 
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(std::string(), TraceLog::RECORD_UNTIL_FULL);
@@ skipping 107 matching lines @@
                        const unsigned char arg_types[],
                        const unsigned long long arg_values[],
                        unsigned char flags) {
     s_instance->collected_events_.push_back(name);
   }
 };
 
 TraceEventCallbackTest* TraceEventCallbackTest::s_instance;
 
 TEST_F(TraceEventCallbackTest, TraceEventCallback) {
-  TRACE_EVENT_INSTANT0("all", "before enable");
+  TRACE_EVENT_INSTANT0("all", "before enable", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEnabled(true, TraceLog::RECORD_UNTIL_FULL);
-  TRACE_EVENT_INSTANT0("all", "before callback set");
+  TRACE_EVENT_INSTANT0("all", "before callback set", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallback(Callback);
-  TRACE_EVENT_INSTANT0("all", "event1");
-  TRACE_EVENT_INSTANT0("all", "event2");
+  TRACE_EVENT_INSTANT0("all", "event1", TRACE_EVENT_SCOPE_GLOBAL);
+  TRACE_EVENT_INSTANT0("all", "event2", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallback(NULL);
-  TRACE_EVENT_INSTANT0("all", "after callback removed");
+  TRACE_EVENT_INSTANT0("all", "after callback removed",
+                       TRACE_EVENT_SCOPE_GLOBAL);
   EXPECT_EQ(2u, collected_events_.size());
   EXPECT_EQ("event1", collected_events_[0]);
   EXPECT_EQ("event2", collected_events_[1]);
 }
 
 // TODO(dsinclair): Continuous Tracing unit test.
 
 }  // namespace debug
 }  // namespace base