Use real process and thread ids when outputting trace-event

runtime/vm/timeline.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <cstdlib>
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_timeline, false, "Trace timeline code.");
 DEFINE_FLAG(bool, complete_timeline, false, "Record the complete timeline");
 
 TimelineEvent::TimelineEvent()
     : timestamp0_(0),
       timestamp1_(0),
       arguments_(NULL),
       arguments_length_(0),
       state_(0),
       label_(NULL),
       stream_(NULL),
-      thread_(NULL) {
+      thread_(OSThread::kInvalidThreadId) {
 }
 
 
 TimelineEvent::~TimelineEvent() {
   Reset();
 }
 
 
 void TimelineEvent::Reset() {
   set_event_type(kNone);
-  thread_ = NULL;
+  thread_ = OSThread::kInvalidThreadId;
   stream_ = NULL;
   label_ = NULL;
   FreeArguments();
 }
 
 
 int64_t TimelineEvent::AsyncBegin(const char* label) {
   Init(kAsyncBegin, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
   ASSERT(stream_ != NULL);
@@ skipping 115 matching lines @@
   stream_ = stream;
 }
 
 
 void TimelineEvent::Init(EventType event_type,
                          const char* label) {
   ASSERT(label != NULL);
   set_event_type(event_type);
   timestamp0_ = 0;
   timestamp1_ = 0;
-  thread_ = Thread::Current();
+  thread_ = OSThread::GetCurrentThreadId();
   label_ = label;
   FreeArguments();
 }
 
 
-static int64_t GetPid(Isolate* isolate) {
-  // Some mapping from Isolate* to an integer process id.
-  // TODO(Cutch): Investigate if process ids can be strings.
-  return static_cast<int64_t>(reinterpret_cast<uintptr_t>(isolate));
-}
-
-
-static int64_t GetTid(Thread* thread) {
-  // Some mapping from Thread* to an integer thread id.
-  // TODO(Cutch): Investigate if process ids can be strings.
-  return static_cast<int64_t>(reinterpret_cast<uintptr_t>(thread));
-}
-
-
 void TimelineEvent::PrintJSON(JSONStream* stream) const {
   JSONObject obj(stream);
-  int64_t pid = GetPid(Isolate::Current());
-  int64_t tid = GetTid(thread_);
+  int64_t pid = OS::ProcessId();
+  int64_t tid = OSThread::ThreadIdToIntPtr(thread_);
   obj.AddProperty("name", label_);
   obj.AddProperty("cat", stream_->name());
   obj.AddProperty64("tid", tid);
   obj.AddProperty64("pid", pid);
   obj.AddPropertyTimeMillis("ts", TimeOrigin());
 
   switch (event_type()) {
     case kDuration: {
       obj.AddProperty("ph", "X");
       obj.AddPropertyTimeMillis("dur", TimeDuration());
@@ skipping 128 matching lines @@
 
   event_->SetArgument(i, name, buffer);
 }
 
 
 TimelineEventRecorder::TimelineEventRecorder() {
 }
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
-  Isolate* isolate = Isolate::Current();
-  JSONObject obj(events);
-  int64_t pid = GetPid(isolate);
-  obj.AddProperty("ph", "M");
-  obj.AddProperty64("pid", pid);
-  obj.AddProperty("name", "process_name");
-  {
-    JSONObject args(&obj, "args");
-    args.AddProperty("name", isolate->debugger_name());
-  }
 }
 
 
 void TimelineEventRecorder::WriteTo(const char* directory) {
   Isolate* isolate = Isolate::Current();
 
   Dart_FileOpenCallback file_open = Isolate::file_open_callback();
   Dart_FileWriteCallback file_write = Isolate::file_write_callback();
   Dart_FileCloseCallback file_close = Isolate::file_close_callback();
   if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
@@ skipping 238 matching lines @@
       length_(0) {
 }
 
 
 TimelineEvent* TimelineEventBlock::StartEvent() {
   ASSERT(!IsFull());
   return &events_[length_++];
 }
 
 }  // namespace dart