Fixed GPU tracing so the categories do not get mixed.

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 <map>
 #include <set>
 
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
  public:
   MockOutputter() {}
   MOCK_METHOD4(Trace,
                void(const std::string& category, const std::string& name,
                     int64 start_time, int64 end_time));
 
  protected:
   ~MockOutputter() {}
 };
 
-class GlFakeQueries {
+class GlFakeTraceQueries {
  public:
-  GlFakeQueries() {}
+  GlFakeTraceQueries() {}
 
   void Reset() {
     current_time_ = 0;
     next_query_id_ = 23;
     alloced_queries_.clear();
     query_timestamp_.clear();
   }
 
   void SetCurrentGLTime(GLint64 current_time) { current_time_ = current_time; }
 
@@ skipping 48 matching lines @@
     }
   }
 
  protected:
   GLint64 current_time_;
   GLuint next_query_id_;
   std::set<GLuint> alloced_queries_;
   std::map<GLuint, GLint64> query_timestamp_;
 };
 
-class BaseGpuTracerTest : public GpuServiceTest {
+class BaseGpuTraceTest : public GpuServiceTest {
  public:
-  BaseGpuTracerTest() {}
+  BaseGpuTraceTest() {}
 
   ///////////////////////////////////////////////////////////////////////////
 
   void DoTraceTest() {
     MockOutputter* outputter = new MockOutputter();
     scoped_refptr<Outputter> outputter_ref = outputter;
 
     SetupTimerQueryMocks();
 
     // Expected results
@@ skipping 45 matching lines @@
     gl_fake_queries_.Reset();
   }
 
   void TearDown() override {
     gl_.reset();
     gl_fake_queries_.Reset();
     GpuServiceTest::TearDown();
   }
 
   virtual void SetupTimerQueryMocks() {
-    // Delegate query APIs used by GPUTrace to a GlFakeQueries
+    // Delegate query APIs used by GPUTrace to a GlFakeTraceQueries
     EXPECT_CALL(*gl_, GenQueriesARB(_, NotNull())).Times(AtLeast(1)).WillOnce(
-        Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueriesARB));
+        Invoke(&gl_fake_queries_, &GlFakeTraceQueries::GenQueriesARB));
 
     EXPECT_CALL(*gl_, GetQueryObjectiv(_, GL_QUERY_RESULT_AVAILABLE, NotNull()))
         .Times(AtLeast(2))
         .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectiv));
+             Invoke(&gl_fake_queries_, &GlFakeTraceQueries::GetQueryObjectiv));
 
     EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP))
         .Times(AtLeast(2))
         .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::QueryCounter));
+             Invoke(&gl_fake_queries_, &GlFakeTraceQueries::QueryCounter));
 
     EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
         .Times(AtLeast(2))
         .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectui64v));
+             Invoke(&gl_fake_queries_,
+                    &GlFakeTraceQueries::GetQueryObjectui64v));
 
     EXPECT_CALL(*gl_, DeleteQueriesARB(2, NotNull()))
         .Times(AtLeast(1))
         .WillRepeatedly(
-             Invoke(&gl_fake_queries_, &GlFakeQueries::DeleteQueriesARB));
+             Invoke(&gl_fake_queries_, &GlFakeTraceQueries::DeleteQueriesARB));
   }
 
   virtual GpuTracerType GetTracerType() = 0;
 
-  GlFakeQueries gl_fake_queries_;
+  GlFakeTraceQueries gl_fake_queries_;
 };
 
-class GpuARBTimerTracerTest : public BaseGpuTracerTest {
+class GpuARBTimerTraceTest : public BaseGpuTraceTest {
  protected:
   GpuTracerType GetTracerType() override { return kTracerTypeARBTimer; }
 };
 
-class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
+class GpuDisjointTimerTraceTest : public BaseGpuTraceTest {
  protected:
   GpuTracerType GetTracerType() override { return kTracerTypeDisjointTimer; }
 };
 
-TEST_F(GpuARBTimerTracerTest, GPUTrace) {
+TEST_F(GpuARBTimerTraceTest, ARBTimerTest) {
   // Test basic timer query functionality
-  {
-    DoTraceTest();
-  }
+  DoTraceTest();
 }
 
-TEST_F(GpuDisjointTimerTracerTest, GPUTrace) {
+TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTest) {
   // Test basic timer query functionality
-  {
-    DoTraceTest();
+  DoTraceTest();
+}
+
+// Test GPU Tracer
+class MockGPUTracer : public GPUTracer {

[vmiura, 2014/12/19 00:30:15]

This is not really a "Mock", I guess.

I think you could use BaseGpuTraceTest which sets up fake GL Apis, and run with
one of the timer extensions enabled.

This would allow more code coverage, and testing for example that
BeginDecoding/EndDecoding do the right things for pausing & resuming traces.

+ public:
+  MockGPUTracer()
+      : GPUTracer(NULL),
+        tracing_enabled_(0) {
+    // Do not have the Mock GPU Tracer issue any GL calls.
+    tracer_type_ = kTracerTypeInvalid;
+
+    // Force tracing to be dependent on our mock variable here.
+    gpu_trace_srv_category = &tracing_enabled_;
+    gpu_trace_dev_category = &tracing_enabled_;
   }
+
+  ~MockGPUTracer() {
+  }
+
+  void SetTracingEnabled(bool enabled) {
+    tracing_enabled_ = enabled ? 1 : 0;
+  }
+
+ protected:
+  unsigned char tracing_enabled_;
+};
+
+TEST(GpuTracerTest, IsTracingTest) {
+  MockGPUTracer mock_tracer;
+  EXPECT_FALSE(mock_tracer.IsTracing());
+  mock_tracer.SetTracingEnabled(true);
+  EXPECT_TRUE(mock_tracer.IsTracing());
+}
+
+TEST(GpuTracerTest, DecodeTest) {
+  MockGPUTracer mock_tracer;
+  ASSERT_TRUE(mock_tracer.BeginDecoding());
+  EXPECT_FALSE(mock_tracer.BeginDecoding());
+  ASSERT_TRUE(mock_tracer.EndDecoding());
+  EXPECT_FALSE(mock_tracer.EndDecoding());
+}
+
+TEST(GpuTracerTest, TraceDuringDecodeTest) {
+  MockGPUTracer mock_tracer;
+  const std::string category_name("trace_category");
+  const std::string trace_name("trace_test");
+
+  EXPECT_FALSE(mock_tracer.Begin(category_name, trace_name, kTraceGroupMarker));
+
+  ASSERT_TRUE(mock_tracer.BeginDecoding());
+  EXPECT_TRUE(mock_tracer.Begin(category_name, trace_name, kTraceGroupMarker));
+  ASSERT_TRUE(mock_tracer.EndDecoding());
+}
+
+TEST(GpuTracerTest, TraceSourceTest) {
+  MockGPUTracer mock_tracer;
+  ASSERT_TRUE(mock_tracer.BeginDecoding());
+
+  // Begin a trace for all each source type.
+  const std::string group_category("group_category");
+  const std::string group_name("group_test");
+  ASSERT_TRUE(mock_tracer.Begin(group_category, group_name, kTraceGroupMarker));
+
+  const std::string chromium_category("chromium_category");
+  const std::string chromium_name("chromium_test");
+  ASSERT_TRUE(mock_tracer.Begin(chromium_category, chromium_name,
+                                kTraceCHROMIUM));
+
+  const std::string decoder_category("decoder_category");
+  const std::string decoder_name("decoder_test");
+  ASSERT_TRUE(mock_tracer.Begin(decoder_category, decoder_name, kTraceDecoder));
+
+  // Each source type should have it's own current category/name.
+  EXPECT_EQ(group_category, mock_tracer.CurrentCategory(kTraceGroupMarker));
+  EXPECT_EQ(group_name, mock_tracer.CurrentName(kTraceGroupMarker));
+
+  EXPECT_EQ(chromium_category, mock_tracer.CurrentCategory(kTraceCHROMIUM));
+  EXPECT_EQ(chromium_name, mock_tracer.CurrentName(kTraceCHROMIUM));
+
+  EXPECT_EQ(decoder_category, mock_tracer.CurrentCategory(kTraceDecoder));
+  EXPECT_EQ(decoder_name, mock_tracer.CurrentName(kTraceDecoder));
+
+  // End each source trace.
+  ASSERT_TRUE(mock_tracer.End(kTraceGroupMarker));
+  ASSERT_TRUE(mock_tracer.End(kTraceCHROMIUM));
+  ASSERT_TRUE(mock_tracer.End(kTraceDecoder));
+
+  // Should be nothing tracing now
+  const std::string empty_string;
+  EXPECT_EQ(empty_string, mock_tracer.CurrentCategory(kTraceGroupMarker));
+  EXPECT_EQ(empty_string, mock_tracer.CurrentName(kTraceGroupMarker));
+
+  EXPECT_EQ(empty_string, mock_tracer.CurrentCategory(kTraceCHROMIUM));
+  EXPECT_EQ(empty_string, mock_tracer.CurrentName(kTraceCHROMIUM));
+
+  EXPECT_EQ(empty_string, mock_tracer.CurrentCategory(kTraceDecoder));
+  EXPECT_EQ(empty_string, mock_tracer.CurrentName(kTraceDecoder));
+
+  ASSERT_TRUE(mock_tracer.EndDecoding());
 }
 
 }  // namespace gles2
 }  // namespace gpu