Binds an ID to a Globally Unique ID.

base/trace_event/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/trace_event/trace_event.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 500 matching lines @@
     TRACE_EVENT_ENTER_CONTEXT("all", "TRACE_EVENT_ENTER_CONTEXT call",
                               TRACE_ID_WITH_SCOPE("scope", context_id));
     TRACE_EVENT_LEAVE_CONTEXT("all", "TRACE_EVENT_LEAVE_CONTEXT call",
                               TRACE_ID_WITH_SCOPE("scope", context_id));
     TRACE_EVENT_SCOPED_CONTEXT("disabled-by-default-cat",
                                "TRACE_EVENT_SCOPED_CONTEXT disabled call",
                                context_id);
     TRACE_EVENT_SCOPED_CONTEXT("all", "TRACE_EVENT_SCOPED_CONTEXT call",
                                context_id);
 
-    TRACE_BIND_IDS("all", "TRACE_BIND_IDS simple call", 0x1000, 0x2000);
-    TRACE_BIND_IDS("all", "TRACE_BIND_IDS scoped call",
+    TRACE_LINK_IDS("all", "simple linking", 0x1000, 0x2000);
+    TRACE_LINK_IDS("all", "link scoped ids",
                    TRACE_ID_WITH_SCOPE("scope 1", 0x1000),
                    TRACE_ID_WITH_SCOPE("scope 2", 0x2000));
+    TRACE_LINK_IDS("all", "link to a global id", 0x1000,
+                   GLOBAL_TRACE_ID_WITH_SCOPE("scope", 0x2000));
+    TRACE_LINK_IDS("all", "link from a global id",
+                   GLOBAL_TRACE_ID(0x1000), 0x2000);
+    TRACE_LINK_IDS("all", "link to a composite id", 0x1000,
+                   GLOBAL_TRACE_ID_WITH_SCOPE("scope", 0x2000, 0x3000));
   }  // 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) \
@@ skipping 421 matching lines @@
     std::string ph;
     EXPECT_TRUE((item && item->GetString("ph", &ph)));
     EXPECT_EQ(")", ph);
 
     std::string id;
     EXPECT_FALSE((item && item->HasKey("scope")));
     EXPECT_TRUE((item && item->GetString("id", &id)));
     EXPECT_EQ("0x20151021", id);
   }
 
-  EXPECT_FIND_("TRACE_BIND_IDS simple call");
+  EXPECT_FIND_("simple linking");
   {
     std::string ph;
     EXPECT_TRUE((item && item->GetString("ph", &ph)));
     EXPECT_EQ("=", ph);
 
     EXPECT_FALSE((item && item->HasKey("scope")));
-    std::string id;
-    EXPECT_TRUE((item && item->GetString("id", &id)));
-    EXPECT_EQ("0x1000", id);
+    EXPECT_FALSE((item && item->HasKey("id_is_global")));
+    std::string id1;
+    EXPECT_TRUE((item && item->GetString("id", &id1)));
+    EXPECT_EQ("0x1000", id1);
 
-    EXPECT_FALSE((item && item->HasKey("args.bind_scope")));
-    std::string bind_id;
-    EXPECT_TRUE((item && item->GetString("bind_id", &id)));
-    EXPECT_EQ("0x2000", id);
+    EXPECT_FALSE((item && item->HasKey("args.linked_id.scope")));
+    EXPECT_FALSE((item && item->HasKey("args.linked_id.id_is_global")));
+    std::string id2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
+    EXPECT_EQ("0x2000", id2);
   }
 
-  EXPECT_FIND_("TRACE_BIND_IDS scoped call");
+  EXPECT_FIND_("link scoped ids");
   {
     std::string ph;
     EXPECT_TRUE((item && item->GetString("ph", &ph)));
     EXPECT_EQ("=", ph);
 
-    std::string id_scope;
-    EXPECT_TRUE((item && item->GetString("scope", &id_scope)));
-    EXPECT_EQ("scope 1", id_scope);
-    std::string id;
-    EXPECT_TRUE((item && item->GetString("id", &id)));
-    EXPECT_EQ("0x1000", id);
+    std::string scope1;
+    EXPECT_TRUE((item && item->GetString("scope", &scope1)));
+    EXPECT_EQ("scope 1", scope1);
+    std::string id1;
+    EXPECT_TRUE((item && item->GetString("id", &id1)));
+    EXPECT_EQ("0x1000", id1);
 
-    std::string bind_scope;
-    EXPECT_TRUE((item && item->GetString("args.bind_scope", &bind_scope)));
-    EXPECT_EQ("scope 2", bind_scope);
-    std::string bind_id;
-    EXPECT_TRUE((item && item->GetString("bind_id", &id)));
-    EXPECT_EQ("0x2000", id);
+    std::string scope2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.scope", &scope2)));
+    EXPECT_EQ("scope 2", scope2);
+    std::string id2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
+    EXPECT_EQ("0x2000", id2);
   }
 
+  EXPECT_FIND_("link to a global id");
+  {
+    std::string ph;
+    EXPECT_TRUE((item && item->GetString("ph", &ph)));
+    EXPECT_EQ("=", ph);
+
+    EXPECT_FALSE((item && item->HasKey("scope")));
+    std::string id1;
+    EXPECT_TRUE((item && item->GetString("id", &id1)));
+    EXPECT_EQ("0x1000", id1);
+
+    std::string scope2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.scope", &scope2)));
+    EXPECT_EQ("scope", scope2);
+    std::string id2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
+    EXPECT_EQ("0x2000", id2);
+    bool id2_is_global;
+    EXPECT_TRUE((item && item->GetBoolean("args.linked_id.id_is_global",
+                                          &id2_is_global)));
+    EXPECT_TRUE(id2_is_global);
+  }
+
+  EXPECT_FIND_("link from a global id");
+  {
+    std::string ph;
+    EXPECT_TRUE((item && item->GetString("ph", &ph)));
+    EXPECT_EQ("=", ph);
+
+    EXPECT_FALSE((item && item->HasKey("scope")));
+    std::string id1;
+    EXPECT_TRUE((item && item->GetString("id", &id1)));
+    EXPECT_EQ("0x1000", id1);
+    bool id1_is_global;
+    EXPECT_TRUE((item && item->GetBoolean("id_is_global", &id1_is_global)));
+    EXPECT_TRUE(id1_is_global);
+
+    EXPECT_FALSE((item && item->HasKey("args.linked_id.scope")));
+    EXPECT_FALSE((item && item->HasKey("args.linked_id.id_is_global")));
+    std::string id2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.id", &id2)));
+    EXPECT_EQ("0x2000", id2);
+  }
+
+  EXPECT_FIND_("link to a composite id");
+  {
+    std::string ph;
+    EXPECT_TRUE((item && item->GetString("ph", &ph)));
+    EXPECT_EQ("=", ph);
+
+    EXPECT_FALSE((item && item->HasKey("scope")));
+    std::string id1;
+    EXPECT_TRUE((item && item->GetString("id", &id1)));
+    EXPECT_EQ("0x1000", id1);
+
+    std::string scope2;
+    EXPECT_TRUE((item && item->GetString("args.linked_id.scope", &scope2)));
+    EXPECT_EQ("scope", scope2);
+    const ListValue* id2 = NULL;
+    EXPECT_TRUE((item && item->GetList("args.linked_id.id", &id2)));
+    EXPECT_EQ(2u, id2->GetSize());
+    std::string part1, part2;
+    EXPECT_TRUE(id2->GetString(0, &part1));
+    EXPECT_EQ("0x2000", part1);
+    EXPECT_TRUE(id2->GetString(1, &part2));
+    EXPECT_EQ("0x3000", part2);
+    bool id2_is_global;
+    EXPECT_TRUE((item && item->GetBoolean("args.linked_id.id_is_global",
+                                          &id2_is_global)));
+    EXPECT_TRUE(id2_is_global);
+  }
 }
 
 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);
   }
@@ skipping 2205 matching lines @@
 
 TEST_F(TraceEventTestFixture, ClockSyncEventsAreAlwaysAddedToTrace) {
   BeginSpecificTrace("-*");
   TRACE_EVENT_CLOCK_SYNC_RECEIVER(1);
   EndTraceAndFlush();
   EXPECT_TRUE(FindNamePhase("clock_sync", "c"));
 }
 
 }  // namespace trace_event
 }  // namespace base