Add RECORD_AS_MUCH_AS_POSSIBLE mode to TraceOptions.

base/debug/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/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 
 namespace {
 
 // The overhead of TraceEvent above this threshold will be reported in the
 // trace.
 const int kOverheadReportThresholdInMicroseconds = 50;
 
 // String options that can be used to initialize TraceOptions.
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
+const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
 const char kTraceToConsole[] = "trace-to-console";
 const char kEnableSampling[] = "enable-sampling";
 const char kEnableSystrace[] = "enable-systrace";
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 const size_t kTraceBufferChunkSize = TraceBufferChunk::kTraceBufferChunkSize;
+const size_t kTraceEventVectorBigBufferChunks =
+    512000000 / kTraceBufferChunkSize;
 const size_t kTraceEventVectorBufferChunks = 256000 / kTraceBufferChunkSize;
 const size_t kTraceEventRingBufferChunks = kTraceEventVectorBufferChunks / 4;
 const size_t kTraceEventBatchChunks = 1000 / kTraceBufferChunkSize;
 // Can store results for 30 seconds with 1 ms sampling interval.
 const size_t kMonitorTraceEventBufferChunks = 30000 / kTraceBufferChunkSize;
 // ECHO_TO_CONSOLE needs a small buffer to hold the unfinished COMPLETE events.
 const size_t kEchoToConsoleTraceEventBufferChunks = 256;
 
 const int kThreadFlushTimeoutMs = 3000;
 
@@ skipping 908 matching lines @@
   std::vector<std::string>::iterator iter;
 
   base::SplitString(options_string, ',', &split);
   for (iter = split.begin(); iter != split.end(); ++iter) {
     if (*iter == kRecordUntilFull) {
       record_mode = RECORD_UNTIL_FULL;
     } else if (*iter == kRecordContinuously) {
       record_mode = RECORD_CONTINUOUSLY;
     } else if (*iter == kTraceToConsole) {
       record_mode = ECHO_TO_CONSOLE;
+    } else if (*iter == kRecordAsMuchAsPossible) {
+      record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
     } else if (*iter == kEnableSampling) {
       enable_sampling = true;
     } else if (*iter == kEnableSystrace) {
       enable_systrace = true;
     } else {
       NOTREACHED();
     }
   }
 }
 
 std::string TraceOptions::ToString() const {
   std::string ret;
   switch (record_mode) {
     case RECORD_UNTIL_FULL:
       ret = kRecordUntilFull;
       break;
     case RECORD_CONTINUOUSLY:
       ret = kRecordContinuously;
       break;
     case ECHO_TO_CONSOLE:
       ret = kTraceToConsole;
       break;
+    case RECORD_AS_MUCH_AS_POSSIBLE:
+      ret = kRecordAsMuchAsPossible;
+      break;
     default:
       NOTREACHED();
   }
   if (enable_sampling)
     ret = ret + "," + kEnableSampling;
   if (enable_systrace)
     ret = ret + "," + kEnableSystrace;
   return ret;
 }
 
@@ skipping 440 matching lines @@
     const TraceOptions& options) {
   InternalTraceOptions ret =
       options.enable_sampling ? kInternalEnableSampling : kInternalNone;
   switch (options.record_mode) {
     case RECORD_UNTIL_FULL:
       return ret | kInternalRecordUntilFull;
     case RECORD_CONTINUOUSLY:
       return ret | kInternalRecordContinuously;
     case ECHO_TO_CONSOLE:
       return ret | kInternalEchoToConsole;
+    case RECORD_AS_MUCH_AS_POSSIBLE:
+      return ret | kInternalRecordAsMuchAsPossible;
   }
   NOTREACHED();
   return kInternalNone;
 }
 
 CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   return category_filter_;
 }
 
 TraceOptions TraceLog::GetCurrentTraceOptions() const {
   TraceOptions ret;
   InternalTraceOptions option = trace_options();
   ret.enable_sampling = (option & kInternalEnableSampling) != 0;
   if (option & kInternalRecordUntilFull)
     ret.record_mode = RECORD_UNTIL_FULL;
   else if (option & kInternalRecordContinuously)
     ret.record_mode = RECORD_CONTINUOUSLY;
   else if (option & kInternalEchoToConsole)
     ret.record_mode = ECHO_TO_CONSOLE;
+  else if (option & kInternalRecordAsMuchAsPossible)
+    ret.record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
   else
     NOTREACHED();
   return ret;
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
   SetDisabledWhileLocked();
 }
 
@@ skipping 81 matching lines @@
 }
 
 TraceBuffer* TraceLog::CreateTraceBuffer() {
   InternalTraceOptions options = trace_options();
   if (options & kInternalRecordContinuously)
     return new TraceBufferRingBuffer(kTraceEventRingBufferChunks);
   else if ((options & kInternalEnableSampling) && mode_ == MONITORING_MODE)
     return new TraceBufferRingBuffer(kMonitorTraceEventBufferChunks);
   else if (options & kInternalEchoToConsole)
     return new TraceBufferRingBuffer(kEchoToConsoleTraceEventBufferChunks);
+  else if (options & kInternalRecordAsMuchAsPossible)
+    return CreateTraceBufferVectorOfSize(kTraceEventVectorBigBufferChunks);
   return CreateTraceBufferVectorOfSize(kTraceEventVectorBufferChunks);
 }
 
 TraceBuffer* TraceLog::CreateTraceBufferVectorOfSize(size_t max_chunks) {
   return new TraceBufferVector(max_chunks);
 }
 
 TraceEvent* TraceLog::AddEventToThreadSharedChunkWhileLocked(
     TraceEventHandle* handle, bool check_buffer_is_full) {
   lock_.AssertAcquired();
@@ skipping 935 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