tracing: Simplify TraceEventMemoryOverhead, use an enum insted of a map

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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 87 matching lines @@
       if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
         continue;
       DCHECK(chunks_[chunk_index]);
       return chunks_[chunk_index].get();
     }
     return NULL;
   }
 
   void EstimateTraceMemoryOverhead(
       TraceEventMemoryOverhead* overhead) override {
-    overhead->Add("TraceBufferRingBuffer", sizeof(*this));
+    overhead->Add(TraceEventMemoryOverhead::kTraceBuffer, sizeof(*this));
     for (size_t queue_index = queue_head_; queue_index != queue_tail_;
          queue_index = NextQueueIndex(queue_index)) {
       size_t chunk_index = recyclable_chunks_queue_[queue_index];
       if (chunk_index >= chunks_.size())  // Skip uninitialized chunks.
         continue;
       chunks_[chunk_index]->EstimateTraceMemoryOverhead(overhead);
     }
   }
 
  private:
@@ skipping 95 matching lines @@
     }
     return NULL;
   }
 
   void EstimateTraceMemoryOverhead(
       TraceEventMemoryOverhead* overhead) override {
     const size_t chunks_ptr_vector_allocated_size =
         sizeof(*this) + max_chunks_ * sizeof(decltype(chunks_)::value_type);
     const size_t chunks_ptr_vector_resident_size =
         sizeof(*this) + chunks_.size() * sizeof(decltype(chunks_)::value_type);
-    overhead->Add("TraceBufferVector", chunks_ptr_vector_allocated_size,
+    overhead->Add(TraceEventMemoryOverhead::kTraceBuffer,
+                  chunks_ptr_vector_allocated_size,
                   chunks_ptr_vector_resident_size);
     for (size_t i = 0; i < chunks_.size(); ++i) {
       TraceBufferChunk* chunk = chunks_[i].get();
       // Skip the in-flight (nullptr) chunks. They will be accounted by the
       // per-thread-local dumpers, see ThreadLocalEventBuffer::OnMemoryDump.
       if (chunk)
         chunk->EstimateTraceMemoryOverhead(overhead);
     }
   }
 
@@ skipping 26 matching lines @@
   return &chunk_[*event_index];
 }
 
 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",
+    cached_overhead_estimate_->Add(TraceEventMemoryOverhead::kTraceBufferChunk,
                                    sizeof(*this) - sizeof(chunk_));
   }
 
   const size_t num_cached_estimated_events =
-      cached_overhead_estimate_->GetCount("TraceEvent");
+      cached_overhead_estimate_->GetCount(
+          TraceEventMemoryOverhead::kTraceEvent);
   DCHECK_LE(num_cached_estimated_events, size());
 
   if (IsFull() && num_cached_estimated_events == size()) {
     overhead->Update(*cached_overhead_estimate_);
     return;
   }
 
   for (size_t i = num_cached_estimated_events; i < size(); ++i)
     chunk_[i].EstimateTraceMemoryOverhead(cached_overhead_estimate_.get());
 
   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)",
+    overhead->Add(TraceEventMemoryOverhead::kUnusedTraceEvent,
                   num_unused_trace_events * sizeof(TraceEvent));
   }
 
   overhead->Update(*cached_overhead_estimate_);
 }
 
 TraceResultBuffer::OutputCallback
 TraceResultBuffer::SimpleOutput::GetCallback() {
   return Bind(&SimpleOutput::Append, Unretained(this));
 }
@@ skipping 31 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