gpu/command_buffer/service/query_manager.cc

   1 // Copyright (c) 2012 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 "gpu/command_buffer/service/query_manager.h"
   6
   7 #include "base/atomicops.h"
   8 #include "base/bind.h"
   9 #include "base/logging.h"
  10 #include "base/memory/shared_memory.h"
  11 #include "base/numerics/safe_math.h"
  12 #include "base/synchronization/lock.h"
  13 #include "base/time/time.h"
  14 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  15 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
  16 #include "gpu/command_buffer/service/error_state.h"
  17 #include "gpu/command_buffer/service/feature_info.h"
  18 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  19 #include "ui/gl/gl_fence.h"
  20
  21 namespace gpu {
  22 namespace gles2 {
  23
  24 namespace {
  25
  26 class AsyncPixelTransferCompletionObserverImpl
  27     : public AsyncPixelTransferCompletionObserver {
  28  public:
  29   AsyncPixelTransferCompletionObserverImpl(base::subtle::Atomic32 submit_count)
  30       : submit_count_(submit_count), cancelled_(false) {}
  31
  32   void Cancel() {
  33     base::AutoLock locked(lock_);
  34     cancelled_ = true;
  35   }
  36
  37   virtual void DidComplete(const AsyncMemoryParams& mem_params) OVERRIDE {
  38     base::AutoLock locked(lock_);
  39     if (!cancelled_) {
  40       DCHECK(mem_params.buffer().get());
  41       void* data = mem_params.GetDataAddress();
  42       QuerySync* sync = static_cast<QuerySync*>(data);
  43       base::subtle::Release_Store(&sync->process_count, submit_count_);
  44     }
  45   }
  46
  47  private:
  48   virtual ~AsyncPixelTransferCompletionObserverImpl() {}
  49
  50   base::subtle::Atomic32 submit_count_;
  51
  52   base::Lock lock_;
  53   bool cancelled_;
  54
  55   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferCompletionObserverImpl);
  56 };
  57
  58 class AsyncPixelTransfersCompletedQuery
  59     : public QueryManager::Query,
  60       public base::SupportsWeakPtr<AsyncPixelTransfersCompletedQuery> {
  61  public:
  62   AsyncPixelTransfersCompletedQuery(
  63       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
  64
  65   virtual bool Begin() OVERRIDE;
  66   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
  67   virtual bool Process() OVERRIDE;
  68   virtual void Destroy(bool have_context) OVERRIDE;
  69
  70  protected:
  71   virtual ~AsyncPixelTransfersCompletedQuery();
  72
  73   scoped_refptr<AsyncPixelTransferCompletionObserverImpl> observer_;
  74 };
  75
  76 AsyncPixelTransfersCompletedQuery::AsyncPixelTransfersCompletedQuery(
  77     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
  78     : Query(manager, target, shm_id, shm_offset) {
  79 }
  80
  81 bool AsyncPixelTransfersCompletedQuery::Begin() {
  82   return true;
  83 }
  84
  85 bool AsyncPixelTransfersCompletedQuery::End(
  86     base::subtle::Atomic32 submit_count) {
  87   // Get the real shared memory since it might need to be duped to prevent
  88   // use-after-free of the memory.
  89   scoped_refptr<Buffer> buffer =
  90       manager()->decoder()->GetSharedMemoryBuffer(shm_id());
  91   if (!buffer.get())
  92     return false;
  93   AsyncMemoryParams mem_params(buffer, shm_offset(), sizeof(QuerySync));
  94   if (!mem_params.GetDataAddress())
  95     return false;
  96
  97   observer_ = new AsyncPixelTransferCompletionObserverImpl(submit_count);
  98
  99   // Ask AsyncPixelTransferDelegate to run completion callback after all
 100   // previous async transfers are done. No guarantee that callback is run
 101   // on the current thread.
 102   manager()->decoder()->GetAsyncPixelTransferManager()->AsyncNotifyCompletion(
 103       mem_params, observer_.get());
 104
 105   return AddToPendingTransferQueue(submit_count);
 106 }
 107
 108 bool AsyncPixelTransfersCompletedQuery::Process() {
 109   QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
 110       shm_id(), shm_offset(), sizeof(*sync));
 111   if (!sync)
 112     return false;
 113
 114   // Check if completion callback has been run. sync->process_count atomicity
 115   // is guaranteed as this is already used to notify client of a completed
 116   // query.
 117   if (base::subtle::Acquire_Load(&sync->process_count) != submit_count())
 118     return true;
 119
 120   UnmarkAsPending();
 121   return true;
 122 }
 123
 124 void AsyncPixelTransfersCompletedQuery::Destroy(bool /* have_context */) {
 125   if (!IsDeleted()) {
 126     MarkAsDeleted();
 127   }
 128 }
 129
 130 AsyncPixelTransfersCompletedQuery::~AsyncPixelTransfersCompletedQuery() {
 131   if (observer_.get())
 132     observer_->Cancel();
 133 }
 134
 135 }  // namespace
 136
 137 class AllSamplesPassedQuery : public QueryManager::Query {
 138  public:
 139   AllSamplesPassedQuery(
 140       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
 141       GLuint service_id);
 142   virtual bool Begin() OVERRIDE;
 143   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 144   virtual bool Process() OVERRIDE;
 145   virtual void Destroy(bool have_context) OVERRIDE;
 146
 147  protected:
 148   virtual ~AllSamplesPassedQuery();
 149
 150  private:
 151   // Service side query id.
 152   GLuint service_id_;
 153 };
 154
 155 AllSamplesPassedQuery::AllSamplesPassedQuery(
 156     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
 157     GLuint service_id)
 158     : Query(manager, target, shm_id, shm_offset),
 159       service_id_(service_id) {
 160 }
 161
 162 bool AllSamplesPassedQuery::Begin() {
 163   BeginQueryHelper(target(), service_id_);
 164   return true;
 165 }
 166
 167 bool AllSamplesPassedQuery::End(base::subtle::Atomic32 submit_count) {
 168   EndQueryHelper(target());
 169   return AddToPendingQueue(submit_count);
 170 }
 171
 172 bool AllSamplesPassedQuery::Process() {
 173   GLuint available = 0;
 174   glGetQueryObjectuivARB(
 175       service_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
 176   if (!available) {
 177     return true;
 178   }
 179   GLuint result = 0;
 180   glGetQueryObjectuivARB(
 181       service_id_, GL_QUERY_RESULT_EXT, &result);
 182
 183   return MarkAsCompleted(result != 0);
 184 }
 185
 186 void AllSamplesPassedQuery::Destroy(bool have_context) {
 187   if (have_context && !IsDeleted()) {
 188     glDeleteQueriesARB(1, &service_id_);
 189     MarkAsDeleted();
 190   }
 191 }
 192
 193 AllSamplesPassedQuery::~AllSamplesPassedQuery() {
 194 }
 195
 196 class CommandsIssuedQuery : public QueryManager::Query {
 197  public:
 198   CommandsIssuedQuery(
 199       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 200
 201   virtual bool Begin() OVERRIDE;
 202   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 203   virtual bool Process() OVERRIDE;
 204   virtual void Destroy(bool have_context) OVERRIDE;
 205
 206  protected:
 207   virtual ~CommandsIssuedQuery();
 208
 209  private:
 210   base::TimeTicks begin_time_;
 211 };
 212
 213 CommandsIssuedQuery::CommandsIssuedQuery(
 214       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
 215     : Query(manager, target, shm_id, shm_offset) {
 216 }
 217
 218 bool CommandsIssuedQuery::Begin() {
 219   begin_time_ = base::TimeTicks::HighResNow();
 220   return true;
 221 }
 222
 223 bool CommandsIssuedQuery::End(base::subtle::Atomic32 submit_count) {
 224   base::TimeDelta elapsed = base::TimeTicks::HighResNow() - begin_time_;
 225   MarkAsPending(submit_count);
 226   return MarkAsCompleted(elapsed.InMicroseconds());
 227 }
 228
 229 bool CommandsIssuedQuery::Process() {
 230   NOTREACHED();
 231   return true;
 232 }
 233
 234 void CommandsIssuedQuery::Destroy(bool /* have_context */) {
 235   if (!IsDeleted()) {
 236     MarkAsDeleted();
 237   }
 238 }
 239
 240 CommandsIssuedQuery::~CommandsIssuedQuery() {
 241 }
 242
 243 class CommandLatencyQuery : public QueryManager::Query {
 244  public:
 245   CommandLatencyQuery(
 246       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 247
 248   virtual bool Begin() OVERRIDE;
 249   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 250   virtual bool Process() OVERRIDE;
 251   virtual void Destroy(bool have_context) OVERRIDE;
 252
 253  protected:
 254   virtual ~CommandLatencyQuery();
 255 };
 256
 257 CommandLatencyQuery::CommandLatencyQuery(
 258       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
 259     : Query(manager, target, shm_id, shm_offset) {
 260 }
 261
 262 bool CommandLatencyQuery::Begin() {
 263     return true;
 264 }
 265
 266 bool CommandLatencyQuery::End(base::subtle::Atomic32 submit_count) {
 267     base::TimeDelta now = base::TimeTicks::HighResNow() - base::TimeTicks();
 268     MarkAsPending(submit_count);
 269     return MarkAsCompleted(now.InMicroseconds());
 270 }
 271
 272 bool CommandLatencyQuery::Process() {
 273   NOTREACHED();
 274   return true;
 275 }
 276
 277 void CommandLatencyQuery::Destroy(bool /* have_context */) {
 278   if (!IsDeleted()) {
 279     MarkAsDeleted();
 280   }
 281 }
 282
 283 CommandLatencyQuery::~CommandLatencyQuery() {
 284 }
 285
 286
 287 class AsyncReadPixelsCompletedQuery
 288     : public QueryManager::Query,
 289       public base::SupportsWeakPtr<AsyncReadPixelsCompletedQuery> {
 290  public:
 291   AsyncReadPixelsCompletedQuery(
 292       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 293
 294   virtual bool Begin() OVERRIDE;
 295   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 296   virtual bool Process() OVERRIDE;
 297   virtual void Destroy(bool have_context) OVERRIDE;
 298
 299  protected:
 300   void Complete();
 301   virtual ~AsyncReadPixelsCompletedQuery();
 302
 303  private:
 304   bool completed_;
 305   bool complete_result_;
 306 };
 307
 308 AsyncReadPixelsCompletedQuery::AsyncReadPixelsCompletedQuery(
 309     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
 310     : Query(manager, target, shm_id, shm_offset),
 311       completed_(false),
 312       complete_result_(false) {
 313 }
 314
 315 bool AsyncReadPixelsCompletedQuery::Begin() {
 316   return true;
 317 }
 318
 319 bool AsyncReadPixelsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
 320   if (!AddToPendingQueue(submit_count)) {
 321     return false;
 322   }
 323   manager()->decoder()->WaitForReadPixels(
 324       base::Bind(&AsyncReadPixelsCompletedQuery::Complete,
 325                  AsWeakPtr()));
 326
 327   return Process();
 328 }
 329
 330 void AsyncReadPixelsCompletedQuery::Complete() {
 331   completed_ = true;
 332   complete_result_ = MarkAsCompleted(1);
 333 }
 334
 335 bool AsyncReadPixelsCompletedQuery::Process() {
 336   return !completed_ || complete_result_;
 337 }
 338
 339 void AsyncReadPixelsCompletedQuery::Destroy(bool /* have_context */) {
 340   if (!IsDeleted()) {
 341     MarkAsDeleted();
 342   }
 343 }
 344
 345 AsyncReadPixelsCompletedQuery::~AsyncReadPixelsCompletedQuery() {
 346 }
 347
 348
 349 class GetErrorQuery : public QueryManager::Query {
 350  public:
 351   GetErrorQuery(
 352       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 353
 354   virtual bool Begin() OVERRIDE;
 355   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 356   virtual bool Process() OVERRIDE;
 357   virtual void Destroy(bool have_context) OVERRIDE;
 358
 359  protected:
 360   virtual ~GetErrorQuery();
 361
 362  private:
 363 };
 364
 365 GetErrorQuery::GetErrorQuery(
 366       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
 367     : Query(manager, target, shm_id, shm_offset) {
 368 }
 369
 370 bool GetErrorQuery::Begin() {
 371   return true;
 372 }
 373
 374 bool GetErrorQuery::End(base::subtle::Atomic32 submit_count) {
 375   MarkAsPending(submit_count);
 376   return MarkAsCompleted(manager()->decoder()->GetErrorState()->GetGLError());
 377 }
 378
 379 bool GetErrorQuery::Process() {
 380   NOTREACHED();
 381   return true;
 382 }
 383
 384 void GetErrorQuery::Destroy(bool /* have_context */) {
 385   if (!IsDeleted()) {
 386     MarkAsDeleted();
 387   }
 388 }
 389
 390 GetErrorQuery::~GetErrorQuery() {
 391 }
 392
 393 class CommandsCompletedQuery : public QueryManager::Query {
 394  public:
 395   CommandsCompletedQuery(QueryManager* manager,
 396                          GLenum target,
 397                          int32 shm_id,
 398                          uint32 shm_offset);
 399
 400   // Overridden from QueryManager::Query:
 401   virtual bool Begin() OVERRIDE;
 402   virtual bool End(base::subtle::Atomic32 submit_count) OVERRIDE;
 403   virtual bool Process() OVERRIDE;
 404   virtual void Destroy(bool have_context) OVERRIDE;
 405
 406  protected:
 407   virtual ~CommandsCompletedQuery();
 408
 409  private:
 410   scoped_ptr<gfx::GLFence> fence_;
 411 };
 412
 413 CommandsCompletedQuery::CommandsCompletedQuery(QueryManager* manager,
 414                                                GLenum target,
 415                                                int32 shm_id,
 416                                                uint32 shm_offset)
 417     : Query(manager, target, shm_id, shm_offset) {}
 418
 419 bool CommandsCompletedQuery::Begin() { return true; }
 420
 421 bool CommandsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
 422   fence_.reset(gfx::GLFence::Create());
 423   DCHECK(fence_);
 424   return AddToPendingQueue(submit_count);
 425 }
 426
 427 bool CommandsCompletedQuery::Process() {
 428   if (fence_ && !fence_->HasCompleted())
 429     return true;
 430   return MarkAsCompleted(0);
 431 }
 432
 433 void CommandsCompletedQuery::Destroy(bool have_context) {
 434   if (have_context && !IsDeleted()) {
 435     fence_.reset();
 436     MarkAsDeleted();
 437   }
 438 }
 439
 440 CommandsCompletedQuery::~CommandsCompletedQuery() {}
 441
 442 QueryManager::QueryManager(
 443     GLES2Decoder* decoder,
 444     FeatureInfo* feature_info)
 445     : decoder_(decoder),
 446       use_arb_occlusion_query2_for_occlusion_query_boolean_(
 447           feature_info->feature_flags(
 448             ).use_arb_occlusion_query2_for_occlusion_query_boolean),
 449       use_arb_occlusion_query_for_occlusion_query_boolean_(
 450           feature_info->feature_flags(
 451             ).use_arb_occlusion_query_for_occlusion_query_boolean),
 452       query_count_(0) {
 453   DCHECK(!(use_arb_occlusion_query_for_occlusion_query_boolean_ &&
 454            use_arb_occlusion_query2_for_occlusion_query_boolean_));
 455 }
 456
 457 QueryManager::~QueryManager() {
 458   DCHECK(queries_.empty());
 459
 460   // If this triggers, that means something is keeping a reference to
 461   // a Query belonging to this.
 462   CHECK_EQ(query_count_, 0u);
 463 }
 464
 465 void QueryManager::Destroy(bool have_context) {
 466   pending_queries_.clear();
 467   pending_transfer_queries_.clear();
 468   while (!queries_.empty()) {
 469     Query* query = queries_.begin()->second.get();
 470     query->Destroy(have_context);
 471     queries_.erase(queries_.begin());
 472   }
 473 }
 474
 475 QueryManager::Query* QueryManager::CreateQuery(
 476     GLenum target, GLuint client_id, int32 shm_id, uint32 shm_offset) {
 477   scoped_refptr<Query> query;
 478   switch (target) {
 479     case GL_COMMANDS_ISSUED_CHROMIUM:
 480       query = new CommandsIssuedQuery(this, target, shm_id, shm_offset);
 481       break;
 482     case GL_LATENCY_QUERY_CHROMIUM:
 483       query = new CommandLatencyQuery(this, target, shm_id, shm_offset);
 484       break;
 485     case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
 486       // Currently async pixel transfer delegates only support uploads.
 487       query = new AsyncPixelTransfersCompletedQuery(
 488           this, target, shm_id, shm_offset);
 489       break;
 490     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
 491       query = new AsyncReadPixelsCompletedQuery(
 492           this, target, shm_id, shm_offset);
 493       break;
 494     case GL_GET_ERROR_QUERY_CHROMIUM:
 495       query = new GetErrorQuery(this, target, shm_id, shm_offset);
 496       break;
 497     case GL_COMMANDS_COMPLETED_CHROMIUM:
 498       query = new CommandsCompletedQuery(this, target, shm_id, shm_offset);
 499       break;
 500     default: {
 501       GLuint service_id = 0;
 502       glGenQueriesARB(1, &service_id);
 503       DCHECK_NE(0u, service_id);
 504       query = new AllSamplesPassedQuery(
 505           this, target, shm_id, shm_offset, service_id);
 506       break;
 507     }
 508   }
 509   std::pair<QueryMap::iterator, bool> result =
 510       queries_.insert(std::make_pair(client_id, query));
 511   DCHECK(result.second);
 512   return query.get();
 513 }
 514
 515 void QueryManager::GenQueries(GLsizei n, const GLuint* queries) {
 516   DCHECK_GE(n, 0);
 517   for (GLsizei i = 0; i < n; ++i) {
 518     generated_query_ids_.insert(queries[i]);
 519   }
 520 }
 521
 522 bool QueryManager::IsValidQuery(GLuint id) {
 523   GeneratedQueryIds::iterator it = generated_query_ids_.find(id);
 524   return it != generated_query_ids_.end();
 525 }
 526
 527 QueryManager::Query* QueryManager::GetQuery(
 528     GLuint client_id) {
 529   QueryMap::iterator it = queries_.find(client_id);
 530   return it != queries_.end() ? it->second.get() : NULL;
 531 }
 532
 533 void QueryManager::RemoveQuery(GLuint client_id) {
 534   QueryMap::iterator it = queries_.find(client_id);
 535   if (it != queries_.end()) {
 536     Query* query = it->second.get();
 537     RemovePendingQuery(query);
 538     query->MarkAsDeleted();
 539     queries_.erase(it);
 540   }
 541   generated_query_ids_.erase(client_id);
 542 }
 543
 544 void QueryManager::StartTracking(QueryManager::Query* /* query */) {
 545   ++query_count_;
 546 }
 547
 548 void QueryManager::StopTracking(QueryManager::Query* /* query */) {
 549   --query_count_;
 550 }
 551
 552 GLenum QueryManager::AdjustTargetForEmulation(GLenum target) {
 553   switch (target) {
 554     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
 555     case GL_ANY_SAMPLES_PASSED_EXT:
 556       if (use_arb_occlusion_query2_for_occlusion_query_boolean_) {
 557         // ARB_occlusion_query2 does not have a
 558         // GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT
 559         // target.
 560         target = GL_ANY_SAMPLES_PASSED_EXT;
 561       } else if (use_arb_occlusion_query_for_occlusion_query_boolean_) {
 562         // ARB_occlusion_query does not have a
 563         // GL_ANY_SAMPLES_PASSED_EXT
 564         // target.
 565         target = GL_SAMPLES_PASSED_ARB;
 566       }
 567       break;
 568     default:
 569       break;
 570   }
 571   return target;
 572 }
 573
 574 void QueryManager::BeginQueryHelper(GLenum target, GLuint id) {
 575   target = AdjustTargetForEmulation(target);
 576   glBeginQueryARB(target, id);
 577 }
 578
 579 void QueryManager::EndQueryHelper(GLenum target) {
 580   target = AdjustTargetForEmulation(target);
 581   glEndQueryARB(target);
 582 }
 583
 584 QueryManager::Query::Query(
 585      QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
 586     : manager_(manager),
 587       target_(target),
 588       shm_id_(shm_id),
 589       shm_offset_(shm_offset),
 590       submit_count_(0),
 591       pending_(false),
 592       deleted_(false) {
 593   DCHECK(manager);
 594   manager_->StartTracking(this);
 595 }
 596
 597 void QueryManager::Query::RunCallbacks() {
 598   for (size_t i = 0; i < callbacks_.size(); i++) {
 599     callbacks_[i].Run();
 600   }
 601   callbacks_.clear();
 602 }
 603
 604 void QueryManager::Query::AddCallback(base::Closure callback) {
 605   if (pending_) {
 606     callbacks_.push_back(callback);
 607   } else {
 608     callback.Run();
 609   }
 610 }
 611
 612 QueryManager::Query::~Query() {
 613   // The query is getting deleted, either by the client or
 614   // because the context was lost. Call any outstanding
 615   // callbacks to avoid leaks.
 616   RunCallbacks();
 617   if (manager_) {
 618     manager_->StopTracking(this);
 619     manager_ = NULL;
 620   }
 621 }
 622
 623 bool QueryManager::Query::MarkAsCompleted(uint64 result) {
 624   DCHECK(pending_);
 625   QuerySync* sync = manager_->decoder_->GetSharedMemoryAs<QuerySync*>(
 626       shm_id_, shm_offset_, sizeof(*sync));
 627   if (!sync) {
 628     return false;
 629   }
 630
 631   pending_ = false;
 632   sync->result = result;
 633   base::subtle::Release_Store(&sync->process_count, submit_count_);
 634
 635   return true;
 636 }
 637
 638 bool QueryManager::ProcessPendingQueries() {
 639   while (!pending_queries_.empty()) {
 640     Query* query = pending_queries_.front().get();
 641     if (!query->Process()) {
 642       return false;
 643     }
 644     if (query->pending()) {
 645       break;
 646     }
 647     query->RunCallbacks();
 648     pending_queries_.pop_front();
 649   }
 650
 651   return true;
 652 }
 653
 654 bool QueryManager::HavePendingQueries() {
 655   return !pending_queries_.empty();
 656 }
 657
 658 bool QueryManager::ProcessPendingTransferQueries() {
 659   while (!pending_transfer_queries_.empty()) {
 660     Query* query = pending_transfer_queries_.front().get();
 661     if (!query->Process()) {
 662       return false;
 663     }
 664     if (query->pending()) {
 665       break;
 666     }
 667     query->RunCallbacks();
 668     pending_transfer_queries_.pop_front();
 669   }
 670
 671   return true;
 672 }
 673
 674 bool QueryManager::HavePendingTransferQueries() {
 675   return !pending_transfer_queries_.empty();
 676 }
 677
 678 bool QueryManager::AddPendingQuery(Query* query,
 679                                    base::subtle::Atomic32 submit_count) {
 680   DCHECK(query);
 681   DCHECK(!query->IsDeleted());
 682   if (!RemovePendingQuery(query)) {
 683     return false;
 684   }
 685   query->MarkAsPending(submit_count);
 686   pending_queries_.push_back(query);
 687   return true;
 688 }
 689
 690 bool QueryManager::AddPendingTransferQuery(
 691     Query* query,
 692     base::subtle::Atomic32 submit_count) {
 693   DCHECK(query);
 694   DCHECK(!query->IsDeleted());
 695   if (!RemovePendingQuery(query)) {
 696     return false;
 697   }
 698   query->MarkAsPending(submit_count);
 699   pending_transfer_queries_.push_back(query);
 700   return true;
 701 }
 702
 703 bool QueryManager::RemovePendingQuery(Query* query) {
 704   DCHECK(query);
 705   if (query->pending()) {
 706     // TODO(gman): Speed this up if this is a common operation. This would only
 707     // happen if you do being/end begin/end on the same query without waiting
 708     // for the first one to finish.
 709     for (QueryQueue::iterator it = pending_queries_.begin();
 710          it != pending_queries_.end(); ++it) {
 711       if (it->get() == query) {
 712         pending_queries_.erase(it);
 713         break;
 714       }
 715     }
 716     for (QueryQueue::iterator it = pending_transfer_queries_.begin();
 717          it != pending_transfer_queries_.end(); ++it) {
 718       if (it->get() == query) {
 719         pending_transfer_queries_.erase(it);
 720         break;
 721       }
 722     }
 723     if (!query->MarkAsCompleted(0)) {
 724       return false;
 725     }
 726   }
 727   return true;
 728 }
 729
 730 bool QueryManager::BeginQuery(Query* query) {
 731   DCHECK(query);
 732   if (!RemovePendingQuery(query)) {
 733     return false;
 734   }
 735   return query->Begin();
 736 }
 737
 738 bool QueryManager::EndQuery(Query* query, base::subtle::Atomic32 submit_count) {
 739   DCHECK(query);
 740   if (!RemovePendingQuery(query)) {
 741     return false;
 742   }
 743   return query->End(submit_count);
 744 }
 745
 746 }  // namespace gles2
 747 }  // namespace gpu