gpu/command_buffer/service/gpu_tracer_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <map>
   6 #include <set>
   7
   8 #include "base/bind.h"
   9 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
  10 #include "gpu/command_buffer/service/gpu_service_test.h"
  11 #include "gpu/command_buffer/service/gpu_tracer.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "ui/gl/gl_mock.h"
  14 #include "ui/gl/gpu_timing.h"
  15
  16 namespace gpu {
  17 namespace gles2 {
  18 namespace {
  19
  20 using ::testing::_;
  21 using ::testing::AtLeast;
  22 using ::testing::AtMost;
  23 using ::testing::Exactly;
  24 using ::testing::Invoke;
  25 using ::testing::NotNull;
  26 using ::testing::Return;
  27
  28 int64 g_fakeCPUTime = 0;
  29 int64 FakeCpuTime() {
  30   return g_fakeCPUTime;
  31 }
  32
  33 class MockOutputter : public Outputter {
  34  public:
  35   MockOutputter() {}
  36   MOCK_METHOD5(TraceDevice,
  37                void(GpuTracerSource source,
  38                     const std::string& category, const std::string& name,
  39                     int64 start_time, int64 end_time));
  40
  41   MOCK_METHOD3(TraceServiceBegin,
  42                void(GpuTracerSource source,
  43                     const std::string& category, const std::string& name));
  44
  45   MOCK_METHOD3(TraceServiceEnd,
  46                void(GpuTracerSource source,
  47                     const std::string& category, const std::string& name));
  48
  49  protected:
  50   ~MockOutputter() {}
  51 };
  52
  53 class GlFakeQueries {
  54  public:
  55   GlFakeQueries() {}
  56
  57   void Reset() {
  58     current_time_ = 0;
  59     next_query_id_ = 23;
  60     alloced_queries_.clear();
  61     query_timestamp_.clear();
  62   }
  63
  64   void SetCurrentGLTime(GLint64 current_time) { current_time_ = current_time; }
  65   void SetDisjoint() { disjointed_ = true; }
  66
  67   void GenQueries(GLsizei n, GLuint* ids) {
  68     for (GLsizei i = 0; i < n; i++) {
  69       ids[i] = next_query_id_++;
  70       alloced_queries_.insert(ids[i]);
  71     }
  72   }
  73
  74   void DeleteQueries(GLsizei n, const GLuint* ids) {
  75     for (GLsizei i = 0; i < n; i++) {
  76       alloced_queries_.erase(ids[i]);
  77       query_timestamp_.erase(ids[i]);
  78     }
  79   }
  80
  81   void GetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
  82     switch (pname) {
  83       case GL_QUERY_RESULT_AVAILABLE: {
  84         std::map<GLuint, GLint64>::iterator it = query_timestamp_.find(id);
  85         if (it != query_timestamp_.end() && it->second <= current_time_)
  86           *params = 1;
  87         else
  88           *params = 0;
  89         break;
  90       }
  91       default:
  92         FAIL() << "Invalid variable passed to GetQueryObjectiv: " << pname;
  93     }
  94   }
  95
  96   void QueryCounter(GLuint id, GLenum target) {
  97     switch (target) {
  98       case GL_TIMESTAMP:
  99         ASSERT_TRUE(alloced_queries_.find(id) != alloced_queries_.end());
 100         query_timestamp_[id] = current_time_;
 101         break;
 102       default:
 103         FAIL() << "Invalid variable passed to QueryCounter: " << target;
 104     }
 105   }
 106
 107   void GetInteger64v(GLenum pname, GLint64 * data) {
 108     switch (pname) {
 109       case GL_TIMESTAMP:
 110         *data = current_time_;
 111         break;
 112       default:
 113         FAIL() << "Invalid variable passed to GetInteger64v: " << pname;
 114     }
 115   }
 116
 117   void GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
 118     switch (pname) {
 119       case GL_QUERY_RESULT:
 120         ASSERT_TRUE(query_timestamp_.find(id) != query_timestamp_.end());
 121         *params = query_timestamp_.find(id)->second;
 122         break;
 123       default:
 124         FAIL() << "Invalid variable passed to GetQueryObjectui64v: " << pname;
 125     }
 126   }
 127
 128   void GetIntegerv(GLenum pname, GLint* params) {
 129     switch (pname) {
 130       case GL_GPU_DISJOINT_EXT:
 131         *params = static_cast<GLint>(disjointed_);
 132         disjointed_ = false;
 133         break;
 134       default:
 135         FAIL() << "Invalid variable passed to GetIntegerv: " << pname;
 136     }
 137   }
 138
 139   void Finish() {
 140   }
 141
 142   GLenum GetError() {
 143     return GL_NO_ERROR;
 144   }
 145
 146  protected:
 147   bool disjointed_ = false;
 148   GLint64 current_time_ = 0;
 149   GLuint next_query_id_ = 0;
 150   std::set<GLuint> alloced_queries_;
 151   std::map<GLuint, GLint64> query_timestamp_;
 152 };
 153
 154 class GPUTracerTester : public GPUTracer {
 155  public:
 156   explicit GPUTracerTester(gles2::GLES2Decoder* decoder)
 157       : GPUTracer(decoder), tracing_enabled_(0) {
 158     gpu_timing_client_->SetCpuTimeForTesting(base::Bind(&FakeCpuTime));
 159
 160     // Force tracing to be dependent on our mock variable here.
 161     gpu_trace_srv_category = &tracing_enabled_;
 162     gpu_trace_dev_category = &tracing_enabled_;
 163   }
 164
 165   ~GPUTracerTester() override {}
 166
 167   void SetTracingEnabled(bool enabled) {
 168     tracing_enabled_ = enabled ? 1 : 0;
 169   }
 170
 171   void SetOutputter(scoped_refptr<Outputter> outputter) {
 172     set_outputter_ = outputter;
 173   }
 174
 175  protected:
 176   scoped_refptr<Outputter> CreateOutputter(const std::string& name) override {
 177     if (set_outputter_.get()) {
 178       return set_outputter_;
 179     }
 180     return new MockOutputter();
 181   }
 182
 183   void PostTask() override {
 184     // Process synchronously.
 185     Process();
 186   }
 187
 188   unsigned char tracing_enabled_;
 189
 190   scoped_refptr<Outputter> set_outputter_;
 191 };
 192
 193 class BaseGpuTest : public GpuServiceTest {
 194  public:
 195   explicit BaseGpuTest(gfx::GPUTiming::TimerType test_timer_type)
 196       : test_timer_type_(test_timer_type) {
 197   }
 198
 199  protected:
 200   void SetUp() override {
 201     g_fakeCPUTime = 0;
 202     const char* gl_version = "3.2";
 203     const char* extensions = "";
 204     if (GetTimerType() == gfx::GPUTiming::kTimerTypeEXT) {
 205       gl_version = "opengl 2.1";
 206       extensions = "GL_EXT_timer_query";
 207     } else if (GetTimerType() == gfx::GPUTiming::kTimerTypeDisjoint) {
 208       gl_version = "opengl es 3.0";
 209       extensions = "GL_EXT_disjoint_timer_query";
 210     } else if (GetTimerType() == gfx::GPUTiming::kTimerTypeARB) {
 211       // TODO(sievers): The tracer should not depend on ARB_occlusion_query.
 212       // Try merge Query APIs (core, ARB, EXT) into a single binding each.
 213       extensions = "GL_ARB_timer_query GL_ARB_occlusion_query";
 214     }
 215     GpuServiceTest::SetUpWithGLVersion(gl_version, extensions);
 216
 217     // Disjoint check should only be called by kTracerTypeDisjointTimer type.
 218     if (GetTimerType() == gfx::GPUTiming::kTimerTypeDisjoint) {
 219       EXPECT_CALL(*gl_, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(AtLeast(1))
 220           .WillRepeatedly(
 221               Invoke(&gl_fake_queries_, &GlFakeQueries::GetIntegerv));
 222     } else {
 223       EXPECT_CALL(*gl_, GetIntegerv(GL_GPU_DISJOINT_EXT, _)).Times(Exactly(0));
 224     }
 225     gpu_timing_client_ = GetGLContext()->CreateGPUTimingClient();
 226     gpu_timing_client_->SetCpuTimeForTesting(base::Bind(&FakeCpuTime));
 227     gl_fake_queries_.Reset();
 228
 229     outputter_ref_ = new MockOutputter();
 230   }
 231
 232   void TearDown() override {
 233     outputter_ref_ = NULL;
 234     gpu_timing_client_ = NULL;
 235
 236     gl_fake_queries_.Reset();
 237     GpuServiceTest::TearDown();
 238   }
 239
 240   void ExpectTraceQueryMocks() {
 241     if (gpu_timing_client_->IsAvailable() &&
 242         gpu_timing_client_->IsTimerOffsetAvailable()) {
 243       // Delegate query APIs used by GPUTrace to a GlFakeQueries
 244       EXPECT_CALL(*gl_, GenQueries(2, NotNull())).Times(AtLeast(1))
 245           .WillRepeatedly(
 246               Invoke(&gl_fake_queries_, &GlFakeQueries::GenQueries));
 247
 248       EXPECT_CALL(*gl_, GetQueryObjectiv(_, GL_QUERY_RESULT_AVAILABLE,
 249                                             NotNull()))
 250           .WillRepeatedly(
 251               Invoke(&gl_fake_queries_, &GlFakeQueries::GetQueryObjectiv));
 252
 253       EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, _))
 254           .WillRepeatedly(
 255               Invoke(&gl_fake_queries_, &GlFakeQueries::GetInteger64v));
 256
 257       EXPECT_CALL(*gl_, QueryCounter(_, GL_TIMESTAMP)).Times(AtLeast(2))
 258           .WillRepeatedly(
 259                Invoke(&gl_fake_queries_, &GlFakeQueries::QueryCounter));
 260
 261       EXPECT_CALL(*gl_, GetQueryObjectui64v(_, GL_QUERY_RESULT, NotNull()))
 262           .WillRepeatedly(
 263                Invoke(&gl_fake_queries_,
 264                       &GlFakeQueries::GetQueryObjectui64v));
 265
 266       EXPECT_CALL(*gl_, DeleteQueries(2, NotNull())).Times(AtLeast(1))
 267           .WillRepeatedly(
 268                Invoke(&gl_fake_queries_, &GlFakeQueries::DeleteQueries));
 269     }
 270   }
 271
 272   void ExpectOutputterBeginMocks(MockOutputter* outputter,
 273                                  GpuTracerSource source,
 274                                  const std::string& category,
 275                                  const std::string& name) {
 276     EXPECT_CALL(*outputter,
 277                 TraceServiceBegin(source, category, name));
 278   }
 279
 280   void ExpectOutputterEndMocks(MockOutputter* outputter,
 281                                GpuTracerSource source,
 282                                const std::string& category,
 283                                const std::string& name, int64 expect_start_time,
 284                                int64 expect_end_time,
 285                                bool trace_device) {
 286     EXPECT_CALL(*outputter,
 287                 TraceServiceEnd(source, category, name));
 288
 289     if (trace_device) {
 290       EXPECT_CALL(*outputter,
 291                   TraceDevice(source, category, name,
 292                               expect_start_time, expect_end_time))
 293           .Times(Exactly(1));
 294     } else {
 295       EXPECT_CALL(*outputter, TraceDevice(source, category, name,
 296                                           expect_start_time, expect_end_time))
 297           .Times(Exactly(0));
 298     }
 299   }
 300
 301   void ExpectOutputterMocks(MockOutputter* outputter,
 302                             bool tracing_device,
 303                             GpuTracerSource source,
 304                             const std::string& category,
 305                             const std::string& name, int64 expect_start_time,
 306                             int64 expect_end_time) {
 307     ExpectOutputterBeginMocks(outputter, source, category, name);
 308     bool valid_timer = tracing_device &&
 309                        gpu_timing_client_->IsAvailable() &&
 310                        gpu_timing_client_->IsTimerOffsetAvailable();
 311     ExpectOutputterEndMocks(outputter, source, category, name,
 312                             expect_start_time, expect_end_time, valid_timer);
 313   }
 314
 315   void ExpectTracerOffsetQueryMocks() {
 316     if (GetTimerType() != gfx::GPUTiming::kTimerTypeARB) {
 317       EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, NotNull()))
 318           .Times(Exactly(0));
 319     } else {
 320       EXPECT_CALL(*gl_, GetInteger64v(GL_TIMESTAMP, NotNull()))
 321           .Times(AtMost(1))
 322           .WillRepeatedly(
 323               Invoke(&gl_fake_queries_, &GlFakeQueries::GetInteger64v));
 324     }
 325   }
 326
 327   gfx::GPUTiming::TimerType GetTimerType() { return test_timer_type_; }
 328
 329   gfx::GPUTiming::TimerType test_timer_type_;
 330   GlFakeQueries gl_fake_queries_;
 331
 332   scoped_refptr<gfx::GPUTimingClient> gpu_timing_client_;
 333   scoped_refptr<MockOutputter> outputter_ref_;
 334 };
 335
 336 // Test GPUTrace calls all the correct gl calls.
 337 class BaseGpuTraceTest : public BaseGpuTest {
 338  public:
 339   explicit BaseGpuTraceTest(gfx::GPUTiming::TimerType test_timer_type)
 340       : BaseGpuTest(test_timer_type) {}
 341
 342   void DoTraceTest(bool tracing_service, bool tracing_device) {
 343     // Expected results
 344     const GpuTracerSource tracer_source = kTraceGroupMarker;
 345     const std::string category_name("trace_category");
 346     const std::string trace_name("trace_test");
 347     const int64 offset_time = 3231;
 348     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
 349     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
 350     const int64 expect_start_time =
 351         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
 352         offset_time;
 353     const int64 expect_end_time =
 354         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 355
 356     if (tracing_service)
 357       ExpectOutputterMocks(outputter_ref_.get(), tracing_device, tracer_source,
 358                            category_name, trace_name,
 359                            expect_start_time, expect_end_time);
 360
 361     if (tracing_device)
 362       ExpectTraceQueryMocks();
 363
 364     scoped_refptr<GPUTrace> trace = new GPUTrace(
 365         outputter_ref_, gpu_timing_client_.get(), tracer_source,
 366         category_name, trace_name, tracing_service, tracing_device);
 367
 368     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
 369     g_fakeCPUTime = expect_start_time;
 370     trace->Start();
 371
 372     // Shouldn't be available before End() call
 373     gl_fake_queries_.SetCurrentGLTime(end_timestamp);
 374     g_fakeCPUTime = expect_end_time;
 375     if (tracing_device)
 376       EXPECT_FALSE(trace->IsAvailable());
 377
 378     trace->End();
 379
 380     // Shouldn't be available until the queries complete
 381     gl_fake_queries_.SetCurrentGLTime(end_timestamp -
 382                                       base::Time::kNanosecondsPerMicrosecond);
 383     if (tracing_device)
 384       EXPECT_FALSE(trace->IsAvailable());
 385
 386     // Now it should be available
 387     gl_fake_queries_.SetCurrentGLTime(end_timestamp);
 388     EXPECT_TRUE(trace->IsAvailable());
 389
 390     // Proces should output expected Trace results to MockOutputter
 391     trace->Process();
 392
 393     // Destroy trace after we are done.
 394     trace->Destroy(true);
 395
 396     outputter_ref_ = NULL;
 397   }
 398 };
 399
 400 class GpuARBTimerTraceTest : public BaseGpuTraceTest {
 401  public:
 402   GpuARBTimerTraceTest() : BaseGpuTraceTest(gfx::GPUTiming::kTimerTypeARB) {}
 403 };
 404
 405 class GpuDisjointTimerTraceTest : public BaseGpuTraceTest {
 406  public:
 407   GpuDisjointTimerTraceTest()
 408       : BaseGpuTraceTest(gfx::GPUTiming::kTimerTypeDisjoint) {}
 409 };
 410
 411 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestOff) {
 412   DoTraceTest(false, false);
 413 }
 414
 415 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestServiceOnly) {
 416   DoTraceTest(true, false);
 417 }
 418
 419 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestDeviceOnly) {
 420   DoTraceTest(false, true);
 421 }
 422
 423 TEST_F(GpuARBTimerTraceTest, ARBTimerTraceTestBothOn) {
 424   DoTraceTest(true, true);
 425 }
 426
 427 TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTestOff) {
 428   DoTraceTest(false, false);
 429 }
 430
 431 TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTestServiceOnly) {
 432   DoTraceTest(true, false);
 433 }
 434
 435 TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTestDeviceOnly) {
 436   DoTraceTest(false, true);
 437 }
 438
 439 TEST_F(GpuDisjointTimerTraceTest, DisjointTimerTraceTestBothOn) {
 440   DoTraceTest(true, true);
 441 }
 442
 443 // Test GPUTracer calls all the correct gl calls.
 444 class BaseGpuTracerTest : public BaseGpuTest {
 445  public:
 446   explicit BaseGpuTracerTest(gfx::GPUTiming::TimerType test_timer_type)
 447       : BaseGpuTest(test_timer_type) {}
 448
 449   void DoBasicTracerTest() {
 450     ExpectTracerOffsetQueryMocks();
 451
 452     MockGLES2Decoder decoder;
 453     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
 454     GPUTracerTester tracer(&decoder);
 455     tracer.SetTracingEnabled(true);
 456
 457     tracer.SetOutputter(outputter_ref_);
 458
 459     ASSERT_TRUE(tracer.BeginDecoding());
 460     ASSERT_TRUE(tracer.EndDecoding());
 461
 462     outputter_ref_ = NULL;
 463   }
 464
 465   void DoTracerMarkersTest() {
 466     ExpectTracerOffsetQueryMocks();
 467
 468     EXPECT_CALL(*gl_, GetError()).Times(AtLeast(0))
 469           .WillRepeatedly(
 470                Invoke(&gl_fake_queries_, &GlFakeQueries::GetError));
 471
 472     const std::string category_name("trace_category");
 473     const std::string trace_name("trace_test");
 474     const int64 offset_time = 3231;
 475     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
 476     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
 477     const int64 expect_start_time =
 478         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
 479         offset_time;
 480     const int64 expect_end_time =
 481         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 482
 483     MockGLES2Decoder decoder;
 484     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
 485     GPUTracerTester tracer(&decoder);
 486     tracer.SetTracingEnabled(true);
 487
 488     tracer.SetOutputter(outputter_ref_);
 489
 490     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
 491     g_fakeCPUTime = expect_start_time;
 492
 493     ASSERT_TRUE(tracer.BeginDecoding());
 494
 495     ExpectTraceQueryMocks();
 496
 497     // This will test multiple marker sources which overlap one another.
 498     for (int i = 0; i < NUM_TRACER_SOURCES; ++i) {
 499       // Set times so each source has a different time.
 500       gl_fake_queries_.SetCurrentGLTime(
 501           start_timestamp +
 502           (i * base::Time::kNanosecondsPerMicrosecond));
 503       g_fakeCPUTime = expect_start_time + i;
 504
 505       // Each trace name should be different to differentiate.
 506       const char num_char = static_cast<char>('0' + i);
 507       std::string source_category = category_name + num_char;
 508       std::string source_trace_name = trace_name + num_char;
 509
 510       const GpuTracerSource source = static_cast<GpuTracerSource>(i);
 511       ExpectOutputterBeginMocks(outputter_ref_.get(), source,
 512                                 source_category, source_trace_name);
 513       ASSERT_TRUE(tracer.Begin(source_category, source_trace_name, source));
 514     }
 515
 516     for (int i = 0; i < NUM_TRACER_SOURCES; ++i) {
 517       // Set times so each source has a different time.
 518       gl_fake_queries_.SetCurrentGLTime(
 519           end_timestamp +
 520           (i * base::Time::kNanosecondsPerMicrosecond));
 521       g_fakeCPUTime = expect_end_time + i;
 522
 523       // Each trace name should be different to differentiate.
 524       const char num_char = static_cast<char>('0' + i);
 525       std::string source_category = category_name + num_char;
 526       std::string source_trace_name = trace_name + num_char;
 527
 528       bool valid_timer = gpu_timing_client_->IsAvailable() &&
 529                          gpu_timing_client_->IsTimerOffsetAvailable();
 530
 531       const GpuTracerSource source = static_cast<GpuTracerSource>(i);
 532       ExpectOutputterEndMocks(outputter_ref_.get(), source, source_category,
 533                               source_trace_name, expect_start_time + i,
 534                               expect_end_time + i, valid_timer);
 535
 536       // Check if the current category/name are correct for this source.
 537       ASSERT_EQ(source_category, tracer.CurrentCategory(source));
 538       ASSERT_EQ(source_trace_name, tracer.CurrentName(source));
 539
 540       ASSERT_TRUE(tracer.End(source));
 541     }
 542
 543     ASSERT_TRUE(tracer.EndDecoding());
 544
 545     outputter_ref_ = NULL;
 546   }
 547
 548   void DoDisjointTest() {
 549     // Cause a disjoint in a middle of a trace and expect no output calls.
 550     ExpectTracerOffsetQueryMocks();
 551
 552     EXPECT_CALL(*gl_, GetError()).Times(AtLeast(0))
 553           .WillRepeatedly(
 554                Invoke(&gl_fake_queries_, &GlFakeQueries::GetError));
 555
 556     const GpuTracerSource tracer_source = kTraceGroupMarker;
 557     const std::string category_name("trace_category");
 558     const std::string trace_name("trace_test");
 559     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
 560     const int64 offset_time = 3231;
 561     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
 562     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
 563     const int64 expect_start_time =
 564         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
 565         offset_time;
 566     const int64 expect_end_time =
 567         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 568
 569     MockGLES2Decoder decoder;
 570     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
 571     GPUTracerTester tracer(&decoder);
 572     tracer.SetTracingEnabled(true);
 573
 574     tracer.SetOutputter(outputter_ref_);
 575
 576     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
 577     g_fakeCPUTime = expect_start_time;
 578
 579     ASSERT_TRUE(tracer.BeginDecoding());
 580
 581     ExpectTraceQueryMocks();
 582
 583     ExpectOutputterBeginMocks(outputter_ref_.get(), tracer_source,
 584                               category_name, trace_name);
 585     ASSERT_TRUE(tracer.Begin(category_name, trace_name, source));
 586
 587     gl_fake_queries_.SetCurrentGLTime(end_timestamp);
 588     g_fakeCPUTime = expect_end_time;
 589
 590     // Create GPUTimingClient to make sure disjoint value is correct. This
 591     // should not interfere with the tracer's disjoint value.
 592     scoped_refptr<gfx::GPUTimingClient>  disjoint_client =
 593         GetGLContext()->CreateGPUTimingClient();
 594
 595     // We assert here based on the disjoint_client because if disjoints are not
 596     // working properly there is no point testing the tracer output.
 597     ASSERT_FALSE(disjoint_client->CheckAndResetTimerErrors());
 598     gl_fake_queries_.SetDisjoint();
 599     ASSERT_TRUE(disjoint_client->CheckAndResetTimerErrors());
 600
 601     ExpectOutputterEndMocks(outputter_ref_.get(), tracer_source,
 602                             category_name, trace_name,
 603                             expect_start_time, expect_end_time, false);
 604
 605     ASSERT_TRUE(tracer.End(source));
 606     ASSERT_TRUE(tracer.EndDecoding());
 607
 608     outputter_ref_ = NULL;
 609   }
 610 };
 611
 612 class InvalidTimerTracerTest : public BaseGpuTracerTest {
 613  public:
 614   InvalidTimerTracerTest()
 615       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeInvalid) {}
 616 };
 617
 618 class GpuEXTTimerTracerTest : public BaseGpuTracerTest {
 619  public:
 620   GpuEXTTimerTracerTest() : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeEXT) {}
 621 };
 622
 623 class GpuARBTimerTracerTest : public BaseGpuTracerTest {
 624  public:
 625   GpuARBTimerTracerTest()
 626       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeARB) {}
 627 };
 628
 629 class GpuDisjointTimerTracerTest : public BaseGpuTracerTest {
 630  public:
 631   GpuDisjointTimerTracerTest()
 632       : BaseGpuTracerTest(gfx::GPUTiming::kTimerTypeDisjoint) {}
 633 };
 634
 635 TEST_F(InvalidTimerTracerTest, InvalidTimerBasicTracerTest) {
 636   DoBasicTracerTest();
 637 }
 638
 639 TEST_F(GpuEXTTimerTracerTest, EXTTimerBasicTracerTest) {
 640   DoBasicTracerTest();
 641 }
 642
 643 TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerTest) {
 644   DoBasicTracerTest();
 645 }
 646
 647 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerTest) {
 648   DoBasicTracerTest();
 649 }
 650
 651 TEST_F(InvalidTimerTracerTest, InvalidTimerTracerMarkersTest) {
 652   DoTracerMarkersTest();
 653 }
 654
 655 TEST_F(GpuEXTTimerTracerTest, EXTTimerTracerMarkersTest) {
 656   DoTracerMarkersTest();
 657 }
 658
 659 TEST_F(GpuARBTimerTracerTest, ARBTimerBasicTracerMarkersTest) {
 660   DoTracerMarkersTest();
 661 }
 662
 663 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerBasicTracerMarkersTest) {
 664   DoTracerMarkersTest();
 665 }
 666
 667 TEST_F(GpuDisjointTimerTracerTest, DisjointTimerDisjointTraceTest) {
 668   DoDisjointTest();
 669 }
 670
 671 class GPUTracerTest : public GpuServiceTest {
 672  protected:
 673   void SetUp() override {
 674     g_fakeCPUTime = 0;
 675     GpuServiceTest::SetUpWithGLVersion("3.2", "");
 676     decoder_.reset(new MockGLES2Decoder());
 677     EXPECT_CALL(*decoder_, GetGLContext())
 678         .Times(AtMost(1))
 679         .WillRepeatedly(Return(GetGLContext()));
 680     tracer_tester_.reset(new GPUTracerTester(decoder_.get()));
 681   }
 682
 683   void TearDown() override {
 684     tracer_tester_ = nullptr;
 685     decoder_ = nullptr;
 686     GpuServiceTest::TearDown();
 687   }
 688   scoped_ptr<MockGLES2Decoder> decoder_;
 689   scoped_ptr<GPUTracerTester> tracer_tester_;
 690 };
 691
 692 TEST_F(GPUTracerTest, IsTracingTest) {
 693   EXPECT_FALSE(tracer_tester_->IsTracing());
 694   tracer_tester_->SetTracingEnabled(true);
 695   EXPECT_TRUE(tracer_tester_->IsTracing());
 696 }
 697 // Test basic functionality of the GPUTracerTester.
 698 TEST_F(GPUTracerTest, DecodeTest) {
 699   ASSERT_TRUE(tracer_tester_->BeginDecoding());
 700   EXPECT_FALSE(tracer_tester_->BeginDecoding());
 701   ASSERT_TRUE(tracer_tester_->EndDecoding());
 702   EXPECT_FALSE(tracer_tester_->EndDecoding());
 703 }
 704
 705 TEST_F(GPUTracerTest, TraceDuringDecodeTest) {
 706   const std::string category_name("trace_category");
 707   const std::string trace_name("trace_test");
 708
 709   EXPECT_FALSE(
 710       tracer_tester_->Begin(category_name, trace_name, kTraceGroupMarker));
 711
 712   ASSERT_TRUE(tracer_tester_->BeginDecoding());
 713   EXPECT_TRUE(
 714       tracer_tester_->Begin(category_name, trace_name, kTraceGroupMarker));
 715   ASSERT_TRUE(tracer_tester_->EndDecoding());
 716 }
 717
 718 TEST_F(GpuDisjointTimerTracerTest, MultipleClientsDisjointTest) {
 719   scoped_refptr<gfx::GPUTimingClient> client1 =
 720       GetGLContext()->CreateGPUTimingClient();
 721   scoped_refptr<gfx::GPUTimingClient>  client2 =
 722       GetGLContext()->CreateGPUTimingClient();
 723
 724   // Test both clients are initialized as no errors.
 725   ASSERT_FALSE(client1->CheckAndResetTimerErrors());
 726   ASSERT_FALSE(client2->CheckAndResetTimerErrors());
 727
 728   // Issue a disjoint.
 729   gl_fake_queries_.SetDisjoint();
 730
 731   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
 732   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
 733
 734   // Test both are now reset.
 735   ASSERT_FALSE(client1->CheckAndResetTimerErrors());
 736   ASSERT_FALSE(client2->CheckAndResetTimerErrors());
 737
 738   // Issue a disjoint.
 739   gl_fake_queries_.SetDisjoint();
 740
 741   // Test new client disjoint value is cleared.
 742   scoped_refptr<gfx::GPUTimingClient>  client3 =
 743       GetGLContext()->CreateGPUTimingClient();
 744   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
 745   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
 746   ASSERT_FALSE(client3->CheckAndResetTimerErrors());
 747 }
 748
 749 }  // namespace
 750 }  // namespace gles2
 751 }  // namespace gpu