ui: Add ref-counting to GLFence class.

gpu/command_buffer/service/query_manager.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/service/query_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/atomicops.h"
@@ skipping 461 matching lines @@
   bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   void Pause() override;
   void Resume() override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandsCompletedQuery() override;
 
  private:
-  std::unique_ptr<gl::GLFence> fence_;
+  scoped_refptr<gl::GLFence> fence_;
   base::TimeTicks begin_time_;
 };
 
 CommandsCompletedQuery::CommandsCompletedQuery(QueryManager* manager,
                                                GLenum target,
                                                int32_t shm_id,
                                                uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsCompletedQuery::Begin() {
   MarkAsActive();
   begin_time_ = base::TimeTicks::Now();
   return true;
 }
 
 void CommandsCompletedQuery::Pause() {
   MarkAsPaused();
 }
 
 void CommandsCompletedQuery::Resume() {
   MarkAsActive();
 }
 
 bool CommandsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
   if (fence_ && fence_->ResetSupported()) {
     fence_->ResetState();
   }
   else {
-    fence_.reset(gl::GLFence::Create());
+    fence_ = gl::GLFence::Create();
   }
   DCHECK(fence_);
   return AddToPendingQueue(submit_count);
 }
 
 bool CommandsCompletedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
   NOTREACHED();
   return false;
 }
 
 bool CommandsCompletedQuery::Process(bool did_finish) {
   // Note: |did_finish| guarantees that the GPU has passed the fence but
   // we cannot assume that GLFence::HasCompleted() will return true yet as
   // that's not guaranteed by all GLFence implementations.
   if (!did_finish && fence_ && !fence_->HasCompleted())
     return true;
 
   const base::TimeDelta elapsed = base::TimeTicks::Now() - begin_time_;
   return MarkAsCompleted(elapsed.InMicroseconds());
 }
 
 void CommandsCompletedQuery::Destroy(bool have_context) {
   if (have_context && !IsDeleted()) {
-    fence_.reset();
+    fence_ = nullptr;
     MarkAsDeleted();
   }
 }
 
 CommandsCompletedQuery::~CommandsCompletedQuery() {}
 
 class TimeElapsedQuery : public QueryManager::Query {
  public:
   TimeElapsedQuery(QueryManager* manager,
                    GLenum target,
@@ skipping 586 matching lines @@
   for (std::pair<const GLenum, scoped_refptr<Query> >& it : active_queries_) {
     if (it.second->IsPaused()) {
       it.second->Resume();
       DCHECK(it.second->IsActive());
     }
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu