Update from https://crrev.com/320343

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 "base/bind.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
@@ skipping 180 matching lines @@
  public:
   explicit BaseGpuTest(gfx::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::kTimerTypeDisjoint) {
+    if (GetTimerType() == gfx::GPUTiming::kTimerTypeEXT) {
+      gl_version = "opengl 2.1";
+      extensions = "GL_EXT_timer_query";
+    } else if (GetTimerType() == gfx::GPUTiming::kTimerTypeDisjoint) {
       gl_version = "opengl es 3.0";
       extensions = "GL_EXT_disjoint_timer_query";
     } else if (GetTimerType() == gfx::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.
@@ skipping 12 matching lines @@
   }
 
   void TearDown() override {
     outputter_ref_ = NULL;
 
     gl_fake_queries_.Reset();
     GpuServiceTest::TearDown();
   }
 
   void ExpectTraceQueryMocks() {
-    if (GetTimerType() != gfx::GPUTiming::kTimerTypeInvalid) {
+    if (gpu_timing_client_->IsAvailable() &&
+        gpu_timing_client_->IsTimerOffsetAvailable()) {
       // Delegate query APIs used by GPUTrace to a GlFakeQueries
       EXPECT_CALL(*gl_, GenQueriesARB(2, NotNull())).Times(AtLeast(1))
           .WillRepeatedly(
               Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueriesARB));
 
       EXPECT_CALL(*gl_, GetQueryObjectivARB(_, GL_QUERY_RESULT_AVAILABLE,
                                             NotNull()))
           .WillRepeatedly(
               Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectivARB));
 
@@ skipping 41 matching lines @@
                                           expect_start_time, expect_end_time))
           .Times(Exactly(0));
     }
   }
 
   void ExpectOutputterMocks(MockOutputter* outputter,
                             const std::string& category,
                             const std::string& name, int64 expect_start_time,
                             int64 expect_end_time) {
     ExpectOutputterBeginMocks(outputter, category, name);
-    bool valid_timer = GetTimerType() != gfx::GPUTiming::kTimerTypeInvalid;
+    bool valid_timer = gpu_timing_client_->IsAvailable() &&
+                       gpu_timing_client_->IsTimerOffsetAvailable();
     ExpectOutputterEndMocks(outputter, category, name, expect_start_time,
                             expect_end_time, valid_timer);
   }
 
   void ExpectTracerOffsetQueryMocks() {
     if (GetTimerType() != gfx::GPUTiming::kTimerTypeARB) {
       EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, NotNull()))
           .Times(Exactly(0));
     } else {
       EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, NotNull()))
@@ skipping 164 matching lines @@
       gl_fake_queries_.SetCurrentGLTime(
           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;
 
-      bool valid_timer = GetTimerType() != gfx::GPUTiming::kTimerTypeInvalid;
+      bool valid_timer = gpu_timing_client_->IsAvailable() &&
+                         gpu_timing_client_->IsTimerOffsetAvailable();
       ExpectOutputterEndMocks(outputter_ref_.get(), source_category,
                               source_trace_name, expect_start_time + i,
                               expect_end_time + i, valid_timer);
 
       const GpuTracerSource source = static_cast<GpuTracerSource>(i);
 
       // 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));
 
@@ skipping 66 matching lines @@
     outputter_ref_ = NULL;
   }
 };
 
 class InvalidTimerTracerTest : public BaseGpuTracerTest {
  public:
   InvalidTimerTracerTest()
       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeInvalid) {}
 };
 
+class GpuEXTTimerTracerTest : public BaseGpuTracerTest {
+ public:
+  GpuEXTTimerTracerTest() : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeEXT) {}
+};
+
 class GpuARBTimerTracerTest : public BaseGpuTracerTest {
  public:
   GpuARBTimerTracerTest()
       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeARB) {}
 };
 
 class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
  public:
   GpuDisjointTimerTracerTest()
       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeDisjoint) {}
 };
 
 TEST_F(InvalidTimerTracerTest, InvalidTimerBasicTracerTest) {
   DoBasicTracerTest();
 }
 
+TEST_F(GpuEXTTimerTracerTest, EXTTimerBasicTracerTest) {
+  DoBasicTracerTest();
+}
+
 TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerTest) {
   DoBasicTracerTest();
 }
 
 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerTest) {
   DoBasicTracerTest();
 }
 
 TEST_F(InvalidTimerTracerTest, InvalidTimerTracerMarkersTest) {
   DoTracerMarkersTest();
 }
 
+TEST_F(GpuEXTTimerTracerTest, EXTTimerTracerMarkersTest) {
+  DoTracerMarkersTest();
+}
+
 TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerMarkersTest) {
   DoTracerMarkersTest();
 }
 
 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerMarkersTest) {
   DoTracerMarkersTest();
 }
 
 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerDisjointTraceTest) {
   DoDisjointTest();
@@ skipping 73 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