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

gpu/command_buffer/tests/gl_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/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
@@ skipping 153 matching lines @@
   bool mapped_;
   IOSurfaceRef iosurface_;
   const gfx::Size size_;
   gfx::BufferFormat format_;
 };
 #endif  // defined(OS_MACOSX)
 
 }  // namespace
 
 int GLManager::use_count_;
-scoped_refptr<gfx::GLShareGroup>* GLManager::base_share_group_;
-scoped_refptr<gfx::GLSurface>* GLManager::base_surface_;
-scoped_refptr<gfx::GLContext>* GLManager::base_context_;
+scoped_refptr<gl::GLShareGroup>* GLManager::base_share_group_;
+scoped_refptr<gl::GLSurface>* GLManager::base_surface_;
+scoped_refptr<gl::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
       sync_point_manager(NULL),
       share_group_manager(NULL),
       share_mailbox_manager(NULL),
       virtual_manager(NULL),
       bind_generates_resource(false),
       lose_context_when_out_of_memory(false),
       context_lost_allowed(false),
@@ skipping 59 matching lines @@
 
   context_lost_allowed_ = options.context_lost_allowed;
 
   gles2::MailboxManager* mailbox_manager = NULL;
   if (options.share_mailbox_manager) {
     mailbox_manager = options.share_mailbox_manager->mailbox_manager();
   } else if (options.share_group_manager) {
     mailbox_manager = options.share_group_manager->mailbox_manager();
   }
 
-  gfx::GLShareGroup* share_group = NULL;
+  gl::GLShareGroup* share_group = NULL;
   if (options.share_group_manager) {
     share_group = options.share_group_manager->share_group();
   } else if (options.share_mailbox_manager) {
     share_group = options.share_mailbox_manager->share_group();
   }
 
   gles2::ContextGroup* context_group = NULL;
   scoped_refptr<gles2::ShareGroup> client_share_group;
   if (options.share_group_manager) {
     context_group = options.share_group_manager->decoder_->GetContextGroup();
     client_share_group =
       options.share_group_manager->gles2_implementation()->share_group();
   }
 
-  gfx::GLContext* real_gl_context = NULL;
+  gl::GLContext* real_gl_context = NULL;
   if (options.virtual_manager) {
     real_gl_context = options.virtual_manager->context();
   }
 
   mailbox_manager_ =
       mailbox_manager ? mailbox_manager : new gles2::MailboxManagerImpl;
-  share_group_ =
-      share_group ? share_group : new gfx::GLShareGroup;
+  share_group_ = share_group ? share_group : new gl::GLShareGroup;
 
-  gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
+  gl::GpuPreference gpu_preference(gl::PreferDiscreteGpu);
   gles2::ContextCreationAttribHelper attribs;
   attribs.red_size = 8;
   attribs.green_size = 8;
   attribs.blue_size = 8;
   attribs.alpha_size = 8;
   attribs.depth_size = 16;
   attribs.stencil_size = 8;
   attribs.context_type = options.context_type;
   attribs.samples = options.multisampled ? 4 : 0;
   attribs.sample_buffers = options.multisampled ? 1 : 0;
@@ skipping 18 matching lines @@
 
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
 
   decoder_->set_engine(executor_.get());
 
   surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
   ASSERT_TRUE(surface_.get() != NULL) << "could not create offscreen surface";
 
   if (base_context_) {
-    context_ = scoped_refptr<gfx::GLContext>(new gpu::GLContextVirtual(
+    context_ = scoped_refptr<gl::GLContext>(new gpu::GLContextVirtual(
         share_group_.get(), base_context_->get(), decoder_->AsWeakPtr()));
-    ASSERT_TRUE(context_->Initialize(
-        surface_.get(), gfx::PreferIntegratedGpu));
+    ASSERT_TRUE(context_->Initialize(surface_.get(), gl::PreferIntegratedGpu));
   } else {
     if (real_gl_context) {
-      context_ = scoped_refptr<gfx::GLContext>(new gpu::GLContextVirtual(
+      context_ = scoped_refptr<gl::GLContext>(new gpu::GLContextVirtual(
           share_group_.get(), real_gl_context, decoder_->AsWeakPtr()));
-      ASSERT_TRUE(context_->Initialize(
-          surface_.get(), gfx::PreferIntegratedGpu));
+      ASSERT_TRUE(
+          context_->Initialize(surface_.get(), gl::PreferIntegratedGpu));
     } else {
       context_ = gl::init::CreateGLContext(share_group_.get(), surface_.get(),
                                            gpu_preference);
     }
   }
   ASSERT_TRUE(context_.get() != NULL) << "could not create GL context";
 
   ASSERT_TRUE(context_->MakeCurrent(surface_.get()));
 
   if (!decoder_->Initialize(surface_.get(), context_.get(), true, options.size,
@@ skipping 41 matching lines @@
       kStartTransferBufferSize, kMinTransferBufferSize, kMaxTransferBufferSize,
       SharedMemoryLimits::kNoLimit))
       << "Could not init GLES2Implementation";
 
   MakeCurrent();
 }
 
 void GLManager::SetupBaseContext() {
   if (use_count_) {
     #if defined(OS_ANDROID)
-      base_share_group_ = new scoped_refptr<gfx::GLShareGroup>(
-          new gfx::GLShareGroup);
-      gfx::Size size(4, 4);
-      base_surface_ = new scoped_refptr<gfx::GLSurface>(
-          gl::init::CreateOffscreenGLSurface(size));
-      gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
-      base_context_ =
-          new scoped_refptr<gfx::GLContext>(gl::init::CreateGLContext(
-              base_share_group_->get(), base_surface_->get(), gpu_preference));
+    base_share_group_ =
+        new scoped_refptr<gl::GLShareGroup>(new gl::GLShareGroup);
+    gfx::Size size(4, 4);
+    base_surface_ = new scoped_refptr<gl::GLSurface>(
+        gl::init::CreateOffscreenGLSurface(size));
+    gl::GpuPreference gpu_preference(gl::PreferDiscreteGpu);
+    base_context_ = new scoped_refptr<gl::GLContext>(gl::init::CreateGLContext(
+        base_share_group_->get(), base_surface_->get(), gpu_preference));
     #endif
   }
   ++use_count_;
 }
 
 void GLManager::OnFenceSyncRelease(uint64_t release) {
   DCHECK(sync_point_client_);
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   sync_point_client_->ReleaseFenceSync(release);
 }
@@ skipping 11 matching lines @@
   // GLManager does not support being multithreaded at this point, so the fence
   // sync must be released by the time wait is called.
   DCHECK(release_state->IsFenceSyncReleased(release));
   return true;
 }
 
 void GLManager::MakeCurrent() {
   ::gles2::SetGLContext(gles2_implementation_.get());
 }
 
-void GLManager::SetSurface(gfx::GLSurface* surface) {
+void GLManager::SetSurface(gl::GLSurface* surface) {
   decoder_->SetSurface(surface);
 }
 
 void GLManager::Destroy() {
   if (gles2_implementation_.get()) {
     MakeCurrent();
     EXPECT_TRUE(glGetError() == GL_NONE);
     gles2_implementation_->Flush();
     gles2_implementation_.reset();
   }
@@ skipping 184 matching lines @@
 
   // Something went wrong, just run the callback now.
   callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace gpu