CL for testing on Win.

base/trace_event/trace_log.cc

 // Copyright 2015 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_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 205 matching lines @@
   TraceEvent* GetEventByHandle(TraceEventHandle handle) {
     if (!chunk_ || handle.chunk_seq != chunk_->seq() ||
         handle.chunk_index != chunk_index_) {
       return nullptr;
     }
 
     return chunk_->GetEventAt(handle.event_index);
   }
 
   int generation() const { return generation_; }
+  size_t chunk_index() { return chunk_index_; }
 
  private:
   // MessageLoop::DestructionObserver
   void WillDestroyCurrentMessageLoop() override;
 
   // MemoryDumpProvider implementation.
   bool OnMemoryDump(const MemoryDumpArgs& args,
                     ProcessMemoryDump* pmd) override;
 
   void FlushWhileLocked();
@@ skipping 1011 matching lines @@
   if (*category_group_enabled & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
       lock.EnsureAcquired();
       trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
     }
+    if (strcmp(name, "SequencedWorkerPool::Inner::ThreadLoop") == 0) {
+      LOG(ERROR) << "ssid adding event SequencedWorkerPool::Inner::ThreadLoop using " << (thread_local_event_buffer ? "thread_local " : "thread_shared ") << handle.chunk_seq << " " << handle.chunk_index << " " << handle.event_index << " " << name;
+
+      LOG(ERROR) << "ssid sshared index " << thread_shared_chunk_index_ << " local index " << (thread_local_event_buffer? thread_local_event_buffer->chunk_index() : 0);
+    }
 
     if (trace_event) {
       trace_event->Initialize(thread_id,
                               offset_event_timestamp,
                               thread_now,
                               phase,
                               category_group_enabled,
                               name,
                               scope,
                               id,
@@ skipping 162 matching lines @@
     TraceEventETWExport::AddCompleteEndEvent(name);
 #endif  // OS_WIN
 
   std::string console_message;
   if (category_group_enabled_local & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
     if (trace_event) {
       DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
+      if (trace_event->duration().ToInternalValue() != -1) {
+        LOG(ERROR) << "ssid got event from "  << (thread_local_event_buffer_.Get() ? "thread_local" : "thread_shared");
+        if (thread_shared_chunk_ && handle.chunk_index == thread_shared_chunk_index_)
+          LOG(ERROR) << "ssid event if not local is from in flight shared chunk with index " << thread_shared_chunk_index_;
+        else
+          LOG(ERROR) << "ssid event if not local is from logged_events_";
+        LOG(ERROR) << "ssid duration set for handle " << handle.chunk_seq << " " << handle.chunk_index << " " << handle.event_index << " " << name;
+      }
+      CHECK_EQ(trace_event->name(), name);
       trace_event->UpdateDuration(now, thread_now);
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif
     }
 
     if (trace_options() & kInternalEchoToConsole) {
       console_message =
           EventToConsoleMessage(TRACE_EVENT_PHASE_END, now, trace_event);
     }
@@ skipping 287 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal