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

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<gfx::GLFence> fence_;
+  std::unique_ptr<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(gfx::GLFence::Create());
+    fence_.reset(gl::GLFence::Create());
   }
   DCHECK(fence_);
   return AddToPendingQueue(submit_count);
 }
 
 bool CommandsCompletedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
   NOTREACHED();
   return false;
 }
 
@@ skipping 30 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:
   ~TimeElapsedQuery() override;
 
  private:
-  std::unique_ptr<gfx::GPUTimer> gpu_timer_;
+  std::unique_ptr<gl::GPUTimer> gpu_timer_;
 };
 
 TimeElapsedQuery::TimeElapsedQuery(QueryManager* manager,
                                    GLenum target,
                                    int32_t shm_id,
                                    uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
       gpu_timer_(manager->CreateGPUTimer(true)) {}
 
 bool TimeElapsedQuery::Begin() {
@@ skipping 56 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:
   ~TimeStampQuery() override;
 
  private:
-  std::unique_ptr<gfx::GPUTimer> gpu_timer_;
+  std::unique_ptr<gl::GPUTimer> gpu_timer_;
 };
 
 TimeStampQuery::TimeStampQuery(QueryManager* manager,
                                GLenum target,
                                int32_t shm_id,
                                uint32_t shm_offset)
     : Query(manager, target, shm_id, shm_offset),
       gpu_timer_(manager->CreateGPUTimer(false)) {}
 
 bool TimeStampQuery::Begin() {
@@ skipping 65 matching lines @@
           feature_info->feature_flags(
             ).use_arb_occlusion_query_for_occlusion_query_boolean),
       update_disjoints_continually_(false),
       disjoint_notify_shm_id_(-1),
       disjoint_notify_shm_offset_(0),
       disjoints_notified_(0),
       query_count_(0) {
   DCHECK(!(use_arb_occlusion_query_for_occlusion_query_boolean_ &&
            use_arb_occlusion_query2_for_occlusion_query_boolean_));
   DCHECK(decoder);
-  gfx::GLContext* context = decoder_->GetGLContext();
+  gl::GLContext* context = decoder_->GetGLContext();
   if (context) {
     gpu_timing_client_ = context->CreateGPUTimingClient();
   } else {
-    gpu_timing_client_ = new gfx::GPUTimingClient();
+    gpu_timing_client_ = new gl::GPUTimingClient();
   }
 }
 
 QueryManager::~QueryManager() {
   DCHECK(queries_.empty());
 
   // If this triggers, that means something is keeping a reference to
   // a Query belonging to this.
   CHECK_EQ(query_count_, 0u);
 }
@@ skipping 66 matching lines @@
     default: {
       NOTREACHED();
     }
   }
   std::pair<QueryMap::iterator, bool> result =
       queries_.insert(std::make_pair(client_id, query));
   DCHECK(result.second);
   return query.get();
 }
 
-std::unique_ptr<gfx::GPUTimer> QueryManager::CreateGPUTimer(bool elapsed_time) {
+std::unique_ptr<gl::GPUTimer> QueryManager::CreateGPUTimer(bool elapsed_time) {
   return gpu_timing_client_->CreateGPUTimer(elapsed_time);
 }
 
 bool QueryManager::GPUTimingAvailable() {
   return gpu_timing_client_->IsAvailable();
 }
 
 void QueryManager::GenQueries(GLsizei n, const GLuint* queries) {
   DCHECK_GE(n, 0);
   for (GLsizei i = 0; i < n; ++i) {
@@ skipping 305 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