Move code in ui/gl/* from gfx:: to gl::

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 <stdint.h>
 
 #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"
@@ skipping 68 matching lines @@
     }
     return new MockOutputter();
   }
 
   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) {
-  }
+  explicit BaseGpuTest(gl::GPUTiming::TimerType test_timer_type)
+      : test_timer_type_(test_timer_type) {}
 
  protected:
   void SetUp() override {
     g_fakeCPUTime = 0;
     const char* gl_version = "3.2";
     const char* extensions = "";
-    if (GetTimerType() == gfx::GPUTiming::kTimerTypeEXT) {
+    if (GetTimerType() == gl::GPUTiming::kTimerTypeEXT) {
       gl_version = "2.1";
       extensions = "GL_EXT_timer_query";
-    } else if (GetTimerType() == gfx::GPUTiming::kTimerTypeDisjoint) {
+    } else if (GetTimerType() == gl::GPUTiming::kTimerTypeDisjoint) {
       gl_version = "opengl es 3.0";
       extensions = "GL_EXT_disjoint_timer_query";
-    } else if (GetTimerType() == gfx::GPUTiming::kTimerTypeARB) {
+    } else if (GetTimerType() == gl::GPUTiming::kTimerTypeARB) {
       // TODO(sievers): The tracer should not depend on ARB_occlusion_query.
       // Try merge Query APIs (core, ARB, EXT) into a single binding each.
       extensions = "GL_ARB_timer_query GL_ARB_occlusion_query";
     }
     GpuServiceTest::SetUpWithGLVersion(gl_version, extensions);
 
     // Disjoint check should only be called by kTracerTypeDisjointTimer type.
-    if (GetTimerType() == gfx::GPUTiming::kTimerTypeDisjoint)
+    if (GetTimerType() == gl::GPUTiming::kTimerTypeDisjoint)
       gl_fake_queries_.ExpectDisjointCalls(*gl_);
     else
       gl_fake_queries_.ExpectNoDisjointCalls(*gl_);
 
     gpu_timing_client_ = GetGLContext()->CreateGPUTimingClient();
     gpu_timing_client_->SetCpuTimeForTesting(base::Bind(&FakeCpuTime));
     gl_fake_queries_.Reset();
 
     outputter_ref_ = new MockOutputter();
   }
 
   void TearDown() override {
     outputter_ref_ = NULL;
     gpu_timing_client_ = NULL;
 
     gl_fake_queries_.Reset();
     GpuServiceTest::TearDown();
   }
 
   void ExpectTraceQueryMocks() {
     if (gpu_timing_client_->IsAvailable()) {
       // Delegate query APIs used by GPUTrace to a GlFakeQueries
-      const bool elapsed = (GetTimerType() == gfx::GPUTiming::kTimerTypeEXT);
+      const bool elapsed = (GetTimerType() == gl::GPUTiming::kTimerTypeEXT);
       gl_fake_queries_.ExpectGPUTimerQuery(*gl_, elapsed);
     }
   }
 
   void ExpectOutputterBeginMocks(MockOutputter* outputter,
                                  GpuTracerSource source,
                                  const std::string& category,
                                  const std::string& name) {
     EXPECT_CALL(*outputter,
                 TraceServiceBegin(source, category, name));
@@ skipping 50 matching lines @@
     if (tracing_service)
       ExpectOutputterBeginMocks(outputter, source, category, name);
     const bool valid_timer = tracing_device &&
                              gpu_timing_client_->IsAvailable();
     ExpectOutputterEndMocks(outputter, source, category, name,
                             expect_start_time, expect_end_time,
                             tracing_service, valid_timer);
   }
 
   void ExpectTracerOffsetQueryMocks() {
-    if (GetTimerType() != gfx::GPUTiming::kTimerTypeARB) {
+    if (GetTimerType() != gl::GPUTiming::kTimerTypeARB) {
       gl_fake_queries_.ExpectNoOffsetCalculationQuery(*gl_);
     } else {
       gl_fake_queries_.ExpectOffsetCalculationQuery(*gl_);
     }
   }
 
-  gfx::GPUTiming::TimerType GetTimerType() { return test_timer_type_; }
+  gl::GPUTiming::TimerType GetTimerType() { return test_timer_type_; }
 
-  gfx::GPUTiming::TimerType test_timer_type_;
-  gfx::GPUTimingFake gl_fake_queries_;
+  gl::GPUTiming::TimerType test_timer_type_;
+  gl::GPUTimingFake gl_fake_queries_;
 
-  scoped_refptr<gfx::GPUTimingClient> gpu_timing_client_;
+  scoped_refptr<gl::GPUTimingClient> gpu_timing_client_;
   scoped_refptr<MockOutputter> outputter_ref_;
 };
 
 // Test GPUTrace calls all the correct gl calls.
 class BaseGpuTraceTest : public BaseGpuTest {
  public:
-  explicit BaseGpuTraceTest(gfx::GPUTiming::TimerType test_timer_type)
+  explicit BaseGpuTraceTest(gl::GPUTiming::TimerType test_timer_type)
       : BaseGpuTest(test_timer_type) {}
 
   void DoTraceTest(bool tracing_service, bool tracing_device) {
     // Expected results
     const GpuTracerSource tracer_source = kTraceCHROMIUM;
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
@@ skipping 43 matching lines @@
 
     // Destroy trace after we are done.
     trace->Destroy(true);
 
     outputter_ref_ = NULL;
   }
 };
 
 class GpuARBTimerTraceTest : public BaseGpuTraceTest {
  public:
-  GpuARBTimerTraceTest() : BaseGpuTraceTest(gfx::GPUTiming::kTimerTypeARB) {}
+  GpuARBTimerTraceTest() : BaseGpuTraceTest(gl::GPUTiming::kTimerTypeARB) {}
 };
 
 class GpuDisjointTimerTraceTest : public BaseGpuTraceTest {
  public:
   GpuDisjointTimerTraceTest()
-      : BaseGpuTraceTest(gfx::GPUTiming::kTimerTypeDisjoint) {}
+      : BaseGpuTraceTest(gl::GPUTiming::kTimerTypeDisjoint) {}
 };
 
 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestOff) {
   DoTraceTest(false, false);
 }
 
 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestServiceOnly) {
   DoTraceTest(true, false);
 }
 
@@ skipping 17 matching lines @@
   DoTraceTest(false, true);
 }
 
 TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTestBothOn) {
   DoTraceTest(true, true);
 }
 
 // Test GPUTracer calls all the correct gl calls.
 class BaseGpuTracerTest : public BaseGpuTest {
  public:
-  explicit BaseGpuTracerTest(gfx::GPUTiming::TimerType test_timer_type)
+  explicit BaseGpuTracerTest(gl::GPUTiming::TimerType test_timer_type)
       : BaseGpuTest(test_timer_type) {}
 
   void DoBasicTracerTest() {
     ExpectTracerOffsetQueryMocks();
 
     MockGLES2Decoder decoder;
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
 
@@ skipping 205 matching lines @@
 
     ExpectOutputterBeginMocks(outputter_ref_.get(), source,
                               category_name, trace_name);
     ASSERT_TRUE(tracer.Begin(category_name, trace_name, source));
 
     gl_fake_queries_.SetCurrentGLTime(end_timestamp);
     g_fakeCPUTime = expect_end_time;
 
     // Create GPUTimingClient to make sure disjoint value is correct. This
     // should not interfere with the tracer's disjoint value.
-    scoped_refptr<gfx::GPUTimingClient> disjoint_client =
+    scoped_refptr<gl::GPUTimingClient> disjoint_client =
         GetGLContext()->CreateGPUTimingClient();
 
     // We assert here based on the disjoint_client because if disjoints are not
     // working properly there is no point testing the tracer output.
     ASSERT_FALSE(disjoint_client->CheckAndResetTimerErrors());
     gl_fake_queries_.SetDisjoint();
     ASSERT_TRUE(disjoint_client->CheckAndResetTimerErrors());
 
     ExpectDisjointOutputMocks(outputter_ref_.get(),
                               expect_start_time, expect_end_time);
@@ skipping 61 matching lines @@
 
     ASSERT_TRUE(tracer.End(source));
     ASSERT_TRUE(tracer.EndDecoding());
     tracer.ProcessTraces();
   }
 };
 
 class InvalidTimerTracerTest : public BaseGpuTracerTest {
  public:
   InvalidTimerTracerTest()
-      : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeInvalid) {}
+      : BaseGpuTracerTest(gl::GPUTiming::kTimerTypeInvalid) {}
 };
 
 class GpuEXTTimerTracerTest : public BaseGpuTracerTest {
  public:
-  GpuEXTTimerTracerTest() : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeEXT) {}
+  GpuEXTTimerTracerTest() : BaseGpuTracerTest(gl::GPUTiming::kTimerTypeEXT) {}
 };
 
 class GpuARBTimerTracerTest : public BaseGpuTracerTest {
  public:
-  GpuARBTimerTracerTest()
-      : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeARB) {}
+  GpuARBTimerTracerTest() : BaseGpuTracerTest(gl::GPUTiming::kTimerTypeARB) {}
 };
 
 class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
  public:
   GpuDisjointTimerTracerTest()
-      : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeDisjoint) {}
+      : BaseGpuTracerTest(gl::GPUTiming::kTimerTypeDisjoint) {}
 };
 
 TEST_F(InvalidTimerTracerTest, InvalidTimerBasicTracerTest) {
   DoBasicTracerTest();
 }
 
 TEST_F(GpuEXTTimerTracerTest, EXTTimerBasicTracerTest) {
   DoBasicTracerTest();
 }
 
@@ skipping 102 matching lines @@
   EXPECT_FALSE(
       tracer_tester_->Begin(category_name, trace_name, kTraceCHROMIUM));
 
   ASSERT_TRUE(tracer_tester_->BeginDecoding());
   EXPECT_TRUE(
       tracer_tester_->Begin(category_name, trace_name, kTraceCHROMIUM));
   ASSERT_TRUE(tracer_tester_->EndDecoding());
 }
 
 TEST_F(GpuDisjointTimerTracerTest, MultipleClientsDisjointTest) {
-  scoped_refptr<gfx::GPUTimingClient> client1 =
+  scoped_refptr<gl::GPUTimingClient> client1 =
       GetGLContext()->CreateGPUTimingClient();
-  scoped_refptr<gfx::GPUTimingClient>  client2 =
+  scoped_refptr<gl::GPUTimingClient> client2 =
       GetGLContext()->CreateGPUTimingClient();
 
   // Test both clients are initialized as no errors.
   ASSERT_FALSE(client1->CheckAndResetTimerErrors());
   ASSERT_FALSE(client2->CheckAndResetTimerErrors());
 
   // Issue a disjoint.
   gl_fake_queries_.SetDisjoint();
 
   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
 
   // Test both are now reset.
   ASSERT_FALSE(client1->CheckAndResetTimerErrors());
   ASSERT_FALSE(client2->CheckAndResetTimerErrors());
 
   // Issue a disjoint.
   gl_fake_queries_.SetDisjoint();
 
   // Test new client disjoint value is cleared.
-  scoped_refptr<gfx::GPUTimingClient>  client3 =
+  scoped_refptr<gl::GPUTimingClient> client3 =
       GetGLContext()->CreateGPUTimingClient();
   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
   ASSERT_FALSE(client3->CheckAndResetTimerErrors());
 }
 
 }  // namespace
 }  // namespace gles2
 }  // namespace gpu