Have GPUTracer process traces during CommandBuffer Idle time.

gpu/command_buffer/service/gpu_tracer_unittest.cc

 // Copyright 2014 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/bind.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_context.h"
@@ skipping 58 matching lines @@
   }
 
  protected:
   scoped_refptr<Outputter> CreateOutputter(const std::string& name) override {
     if (set_outputter_.get()) {
       return set_outputter_;
     }
     return new MockOutputter();
   }
 
-  void PostTask() override {
-    // Process synchronously.
-    Process();
-  }
-
   unsigned char tracing_enabled_;
-
   scoped_refptr<Outputter> set_outputter_;
 };
 
 class BaseGpuTest : public GpuServiceTest {
  public:
   explicit BaseGpuTest(gfx::GPUTiming::TimerType test_timer_type)
       : test_timer_type_(test_timer_type) {
   }
 
  protected:
@@ skipping 323 matching lines @@
           end_timestamp +
           (i * base::Time::kNanosecondsPerMicrosecond));
       g_fakeCPUTime = expect_end_time + i;
 
       // Each trace name should be different to differentiate.
       const char num_char = static_cast<char>('0' + i);
       std::string source_category = category_name + num_char;
       std::string source_trace_name = trace_name + num_char;
 
       const bool valid_timer = gpu_timing_client_->IsAvailable();
-
       const GpuTracerSource source = static_cast<GpuTracerSource>(i);
       ExpectOutputterEndMocks(outputter_ref_.get(), source, source_category,
                               source_trace_name, expect_start_time + i,
                               expect_end_time + i, true, valid_timer);
       // Check if the current category/name are correct for this source.
       ASSERT_EQ(source_category, tracer.CurrentCategory(source));
       ASSERT_EQ(source_trace_name, tracer.CurrentName(source));
 
       ASSERT_TRUE(tracer.End(source));
     }
     ASSERT_TRUE(tracer.EndDecoding());
+    tracer.ProcessTraces();
     outputter_ref_ = NULL;
   }
 
   void DoOngoingTracerMarkerTest() {
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
@@ skipping 55 matching lines @@
                             trace_name, expect_start_time + 3,
                             expect_start_time + 4, true, valid_timer);
     ASSERT_TRUE(tracer.End(source));
 
     // Increment time before we end decoding to test trace does not stop here.
     gl_fake_queries_.SetCurrentGLTime(
         start_timestamp +
         (5 * base::Time::kNanosecondsPerMicrosecond));
     g_fakeCPUTime = expect_start_time + 5;
     ASSERT_TRUE(tracer.EndDecoding());
+    tracer.ProcessTraces();
   }
 
   void DoDisjointTest() {
     // Cause a disjoint in a middle of a trace and expect no output calls.
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
@@ skipping 40 matching lines @@
 
     ExpectDisjointOutputMocks(outputter_ref_.get(),
                               expect_start_time, expect_end_time);
 
     ExpectOutputterEndMocks(outputter_ref_.get(), source,
                             category_name, trace_name,
                             expect_start_time, expect_end_time, true, false);
 
     ASSERT_TRUE(tracer.End(source));
     ASSERT_TRUE(tracer.EndDecoding());
+    tracer.ProcessTraces();
 
     outputter_ref_ = NULL;
   }
 
   void DoOutsideDisjointTest() {
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
@@ skipping 36 matching lines @@
     // Set times so each source has a different time.
     gl_fake_queries_.SetCurrentGLTime(end_timestamp);
     g_fakeCPUTime = expect_end_time;
 
     ExpectOutputterEndMocks(outputter_ref_.get(), source, category_name,
                             trace_name, expect_start_time,
                             expect_end_time, true, true);
 
     ASSERT_TRUE(tracer.End(source));
     ASSERT_TRUE(tracer.EndDecoding());
+    tracer.ProcessTraces();
   }
 };
 
 class InvalidTimerTracerTest : public BaseGpuTracerTest {
  public:
   InvalidTimerTracerTest()
       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeInvalid) {}
 };
 
 class GpuEXTTimerTracerTest : public BaseGpuTracerTest {
@@ skipping 159 matching lines @@
   scoped_refptr<gfx::GPUTimingClient>  client3 =
       GetGLContext()->CreateGPUTimingClient();
   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
   ASSERT_FALSE(client3->CheckAndResetTimerErrors());
 }
 
 }  // namespace
 }  // namespace gles2
 }  // namespace gpu