Revert of [tracing] Fix, simplify and speed up accounting of TraceEvent memory overhead

base/trace_event/trace_buffer.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_buffer.h"
 
 #include "base/trace_event/trace_event_impl.h"
 
 namespace base {
 namespace trace_event {
@@ skipping 276 matching lines @@
 
 TraceBufferChunk::TraceBufferChunk(uint32 seq) : next_free_(0), seq_(seq) {}
 
 TraceBufferChunk::~TraceBufferChunk() {}
 
 void TraceBufferChunk::Reset(uint32 new_seq) {
   for (size_t i = 0; i < next_free_; ++i)
     chunk_[i].Reset();
   next_free_ = 0;
   seq_ = new_seq;
-  cached_overhead_estimate_.reset();
+  cached_overhead_estimate_when_full_.reset();
 }
 
 TraceEvent* TraceBufferChunk::AddTraceEvent(size_t* event_index) {
   DCHECK(!IsFull());
   *event_index = next_free_++;
   return &chunk_[*event_index];
 }
 
 scoped_ptr<TraceBufferChunk> TraceBufferChunk::Clone() const {
   scoped_ptr<TraceBufferChunk> cloned_chunk(new TraceBufferChunk(seq_));
   cloned_chunk->next_free_ = next_free_;
   for (size_t i = 0; i < next_free_; ++i)
     cloned_chunk->chunk_[i].CopyFrom(chunk_[i]);
   return cloned_chunk.Pass();
 }
 
 void TraceBufferChunk::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
-  if (!cached_overhead_estimate_) {
-    cached_overhead_estimate_.reset(new TraceEventMemoryOverhead);
-
-    // When estimating the size of TraceBufferChunk, exclude the array of trace
-    // events, as they are computed individually below.
-    cached_overhead_estimate_->Add("TraceBufferChunk",
-                                   sizeof(*this) - sizeof(chunk_));
-  }
-
-  const size_t num_cached_estimated_events =
-      cached_overhead_estimate_->GetCount("TraceEvent");
-  DCHECK_LE(num_cached_estimated_events, size());
-
-  if (IsFull() && num_cached_estimated_events == size()) {
-    overhead->Update(*cached_overhead_estimate_);
+  if (cached_overhead_estimate_when_full_) {
+    DCHECK(IsFull());
+    overhead->Update(*cached_overhead_estimate_when_full_);
     return;
   }
 
-  for (size_t i = num_cached_estimated_events; i < size(); ++i)
-    chunk_[i].EstimateTraceMemoryOverhead(cached_overhead_estimate_.get());
+  // Cache the memory overhead estimate only if the chunk is full.
+  TraceEventMemoryOverhead* estimate = overhead;
+  if (IsFull()) {
+    cached_overhead_estimate_when_full_.reset(new TraceEventMemoryOverhead);
+    estimate = cached_overhead_estimate_when_full_.get();
+  }
+
+  estimate->Add("TraceBufferChunk", sizeof(*this));
+  for (size_t i = 0; i < next_free_; ++i)
+    chunk_[i].EstimateTraceMemoryOverhead(estimate);
 
   if (IsFull()) {
-    cached_overhead_estimate_->AddSelf();
-  } else {
-    // The unused TraceEvents in |chunks_| are not cached. They will keep
-    // changing as new TraceEvents are added to this chunk, so they are
-    // computed on the fly.
-    const size_t num_unused_trace_events = capacity() - size();
-    overhead->Add("TraceEvent (unused)",
-                  num_unused_trace_events * sizeof(TraceEvent));
+    estimate->AddSelf();
+    overhead->Update(*estimate);
   }
-
-  overhead->Update(*cached_overhead_estimate_);
 }
 
 TraceResultBuffer::OutputCallback
 TraceResultBuffer::SimpleOutput::GetCallback() {
   return Bind(&SimpleOutput::Append, Unretained(this));
 }
 
 void TraceResultBuffer::SimpleOutput::Append(
     const std::string& json_trace_output) {
   json_output += json_trace_output;
@@ skipping 27 matching lines @@
 TraceBuffer* TraceBuffer::CreateTraceBufferRingBuffer(size_t max_chunks) {
   return new TraceBufferRingBuffer(max_chunks);
 }
 
 TraceBuffer* TraceBuffer::CreateTraceBufferVectorOfSize(size_t max_chunks) {
   return new TraceBufferVector(max_chunks);
 }
 
 }  // namespace trace_event
 }  // namespace base