Add granular file tracing.

base/trace_event/trace_event_impl.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_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base_switches.h"
@@ skipping 288 matching lines @@
  public:
   TraceBufferVector(size_t max_chunks)
       : in_flight_chunk_count_(0),
         current_iteration_index_(0),
         max_chunks_(max_chunks) {
     chunks_.reserve(max_chunks_);
   }
 
   scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) override {
     // This function may be called when adding normal events or indirectly from
-    // AddMetadataEventsWhileLocked(). We can not DECHECK(!IsFull()) because we
+    // AddMetadataEventsWhileLocked(). We can not DCHECK(!IsFull()) because we
     // have to add the metadata events and flush thread-local buffers even if
     // the buffer is full.
     *index = chunks_.size();
     chunks_.push_back(NULL);  // Put NULL in the slot of a in-flight chunk.
     ++in_flight_chunk_count_;
     // + 1 because zero chunk_seq is not allowed.
     return scoped_ptr<TraceBufferChunk>(
         new TraceBufferChunk(static_cast<uint32>(*index) + 1));
   }
 
@@ skipping 397 matching lines @@
     *out += arg_names_[i];
     *out += "\":";
 
     if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
       convertable_values_[i]->AppendAsTraceFormat(out);
     else
       AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
   }
   *out += "}";
 
-  if (phase_ == TRACE_EVENT_PHASE_COMPLETE) {
+  if (phase_ == TRACE_EVENT_PHASE_COMPLETE ||
+      phase_ == TRACE_EVENT_PHASE_NESTABLE_ASYNC_COMPLETE) {
     int64 duration = duration_.ToInternalValue();
     if (duration != -1)
       StringAppendF(out, ",\"dur\":%" PRId64, duration);
     if (!thread_timestamp_.is_null()) {
       int64 thread_duration = thread_duration_.ToInternalValue();
       if (thread_duration != -1)
         StringAppendF(out, ",\"tdur\":%" PRId64, thread_duration);
     }
   }
 
@@ skipping 1332 matching lines @@
 // May be called when a COMPELETE event ends and the unfinished event has been
 // recycled (phase == TRACE_EVENT_PHASE_END and trace_event == NULL).
 std::string TraceLog::EventToConsoleMessage(unsigned char phase,
                                             const TimeTicks& timestamp,
                                             TraceEvent* trace_event) {
   AutoLock thread_info_lock(thread_info_lock_);
 
   // The caller should translate TRACE_EVENT_PHASE_COMPLETE to
   // TRACE_EVENT_PHASE_BEGIN or TRACE_EVENT_END.
   DCHECK(phase != TRACE_EVENT_PHASE_COMPLETE);
+  DCHECK(phase != TRACE_EVENT_PHASE_NESTABLE_ASYNC_COMPLETE);
 
   TimeDelta duration;
   int thread_id = trace_event ?
       trace_event->thread_id() : PlatformThread::CurrentId();
   if (phase == TRACE_EVENT_PHASE_END) {
     duration = timestamp - thread_event_start_times_[thread_id].top();
     thread_event_start_times_[thread_id].pop();
   }
 
   std::string thread_name = thread_names_[thread_id];
@@ skipping 62 matching lines @@
 
   TimeTicks thread_now = ThreadNow();
   TimeTicks now = OffsetNow();
 
   std::string console_message;
   if (*category_group_enabled & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
     if (trace_event) {
-      DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE);
+      DCHECK(trace_event->phase() == TRACE_EVENT_PHASE_COMPLETE ||
+             trace_event->phase() == TRACE_EVENT_PHASE_NESTABLE_ASYNC_COMPLETE);
       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 461 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