Have GPUTracer process traces during CommandBuffer Idle time.

gpu/command_buffer/service/gpu_tracer.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 "gpu/command_buffer/service/gpu_tracer.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_version_info.h"
 #include "ui/gl/gpu_timing.h"
 
 namespace gpu {
 namespace gles2 {
 
-static const unsigned int kProcessInterval = 16;
 static const char* kGpuTraceSourceNames[] = {
   "TraceCHROMIUM", // kTraceCHROMIUM,
   "TraceCmd", // kTraceDecoder,
   "Disjoint", // kTraceDisjoint, // Used internally.
 };
 static_assert(NUM_TRACER_SOURCES == arraysize(kGpuTraceSourceNames),
               "Trace source names must match enumeration.");
 
 static TraceOutputter* g_outputter_thread = NULL;
 
@@ skipping 206 matching lines @@
           TraceMarker& marker = markers_[n][i];
           if (marker.trace_.get()) {
             marker.trace_->End();
 
             finished_traces_.push_back(marker.trace_);
             marker.trace_ = 0;
           }
         }
       }
     }
-    IssueProcessTask();
   }
 
   gpu_executing_ = false;
   return true;
 }
 
 bool GPUTracer::Begin(const std::string& category, const std::string& name,
                       GpuTracerSource source) {
   if (!gpu_executing_)
     return false;
@@ skipping 25 matching lines @@
 
   // Pop last marker with matching 'source'
   if (!markers_[source].empty()) {
     scoped_refptr<GPUTrace> trace = markers_[source].back().trace_;
     if (trace.get()) {
       if (IsTracing()) {
         trace->End();
       }
 
       finished_traces_.push_back(trace);
-      IssueProcessTask();
     }
 
     markers_[source].pop_back();
     return true;
   }
   return false;
 }
 
-bool GPUTracer::IsTracing() {
-  return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
-}
-
-const std::string& GPUTracer::CurrentCategory(GpuTracerSource source) const {
-  if (source >= 0 &&
-      source < NUM_TRACER_SOURCES &&
-      !markers_[source].empty()) {
-    return markers_[source].back().category_;
-  }
-  return base::EmptyString();
-}
-
-const std::string& GPUTracer::CurrentName(GpuTracerSource source) const {
-  if (source >= 0 &&
-      source < NUM_TRACER_SOURCES &&
-      !markers_[source].empty()) {
-    return markers_[source].back().name_;
-  }
-  return base::EmptyString();
-}
-
-scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
-  return TraceOutputter::Create(name);
-}
-
-void GPUTracer::PostTask() {
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
-      base::TimeDelta::FromMilliseconds(kProcessInterval));
-}
-
-void GPUTracer::Process() {
-  process_posted_ = false;
-  ProcessTraces();
-  IssueProcessTask();
+bool GPUTracer::HasTracesToProcess() {
+  return !finished_traces_.empty();
 }
 
 void GPUTracer::ProcessTraces() {
   if (!gpu_timing_client_->IsAvailable()) {
    while (!finished_traces_.empty()) {
       finished_traces_.front()->Destroy(false);
       finished_traces_.pop_front();
     }
     return;
   }
@@ skipping 24 matching lines @@
       scoped_refptr<GPUTrace>& trace = finished_traces_.front();
       trace->Process();
       trace->Destroy(true);
       finished_traces_.pop_front();
     }
   }
 
   DCHECK(GL_NO_ERROR == glGetError());
 }
 
+bool GPUTracer::IsTracing() {
+  return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
+}
+
+const std::string& GPUTracer::CurrentCategory(GpuTracerSource source) const {
+  if (source >= 0 &&
+      source < NUM_TRACER_SOURCES &&
+      !markers_[source].empty()) {
+    return markers_[source].back().category_;
+  }
+  return base::EmptyString();
+}
+
+const std::string& GPUTracer::CurrentName(GpuTracerSource source) const {
+  if (source >= 0 &&
+      source < NUM_TRACER_SOURCES &&
+      !markers_[source].empty()) {
+    return markers_[source].back().name_;
+  }
+  return base::EmptyString();
+}
+
+scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
+  return TraceOutputter::Create(name);
+}
+
 bool GPUTracer::CheckDisjointStatus() {
   const int64 current_time = gpu_timing_client_->GetCurrentCPUTime();
   if (*gpu_trace_dev_category == 0)
     return false;
 
   bool status = gpu_timing_client_->CheckAndResetTimerErrors();
   if (status && began_device_traces_) {
     // Log disjoint event if we have active traces.
     const std::string unique_disjoint_name =
         base::StringPrintf("DisjointEvent-%p", this);
@@ skipping 17 matching lines @@
       }
     }
   }
 
   while (!finished_traces_.empty()) {
     finished_traces_.front()->Destroy(have_context);
     finished_traces_.pop_front();
   }
 }
 
-void GPUTracer::IssueProcessTask() {
-  if (finished_traces_.empty() || process_posted_)
-    return;
-
-  process_posted_ = true;
-  PostTask();
-}
-
 }  // namespace gles2
 }  // namespace gpu