Fixed GPU tracing so the categories do not get mixed.

gpu/command_buffer/service/gpu_tracer_unittest.cc

Index: gpu/command_buffer/service/gpu_tracer_unittest.cc
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index ccf4d6da3cf15a6fb0182c65aa4901e0e68392e5..10c2d4d580ab8ac57c81f94e1e9dfe24e6285eec 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -30,9 +30,9 @@ class MockOutputter : public Outputter {
   ~MockOutputter() {}
 };
 
-class GlFakeQueries {
+class GlFakeTraceQueries {
  public:
-  GlFakeQueries() {}
+  GlFakeTraceQueries() {}
 
   void Reset() {
     current_time_ = 0;
@@ -101,9 +101,9 @@ class GlFakeQueries {
   std::map<GLuint, GLint64> query_timestamp_;
 };
 
-class BaseGpuTracerTest : public GpuServiceTest {
+class BaseGpuTraceTest : public GpuServiceTest {
  public:
-  BaseGpuTracerTest() {}
+  BaseGpuTraceTest() {}
 
   ///////////////////////////////////////////////////////////////////////////
 
@@ -169,58 +169,154 @@ class BaseGpuTracerTest : public GpuServiceTest {
   }
 
   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