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

gpu/ipc/service/gpu_command_buffer_stub.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/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 452 matching lines @@
                                           command_buffer_id_.GetUnsafeValue()),
         manager->shader_translator_cache(),
         manager->framebuffer_completeness_cache(), feature_info,
         init_params.attribs.bind_generates_resource);
   }
 
 #if defined(OS_MACOSX)
   // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
   // performance regressions when enabling FCM.
   // http://crbug.com/180463
-  if (init_params.gpu_preference == gfx::PreferIntegratedGpu)
+  if (init_params.gpu_preference == gl::PreferIntegratedGpu)
     use_virtualized_gl_context_ = true;
 #endif
 
   use_virtualized_gl_context_ |=
       context_group_->feature_info()->workarounds().use_virtualized_gl_contexts;
 
   // MailboxManagerSync synchronization correctness currently depends on having
   // only a single context. See crbug.com/510243 for details.
   use_virtualized_gl_context_ |= channel_->mailbox_manager()->UsesSync();
 
-  gfx::GLSurface::Format surface_format = gfx::GLSurface::SURFACE_DEFAULT;
+  gl::GLSurface::Format surface_format = gl::GLSurface::SURFACE_DEFAULT;
   bool offscreen = (surface_handle_ == kNullSurfaceHandle);
 #if defined(OS_ANDROID)
   if (init_params.attribs.red_size <= 5 &&
       init_params.attribs.green_size <= 6 &&
       init_params.attribs.blue_size <= 5 &&
       init_params.attribs.alpha_size == 0)
-    surface_format = gfx::GLSurface::SURFACE_RGB565;
-  gfx::GLSurface* default_surface = manager->GetDefaultOffscreenSurface();
+    surface_format = gl::GLSurface::SURFACE_RGB565;
+  gl::GLSurface* default_surface = manager->GetDefaultOffscreenSurface();
   // We can only use virtualized contexts for onscreen command buffers if their
   // config is compatible with the offscreen ones - otherwise MakeCurrent fails.
   if (surface_format != default_surface->GetFormat() && !offscreen)
     use_virtualized_gl_context_ = false;
 #endif
 
   gfx::Size initial_size = init_params.size;
   if (offscreen && initial_size.IsEmpty()) {
     // If we're an offscreen surface with zero width and/or height, set to a
     // non-zero size so that we have a complete framebuffer for operations like
@@ skipping 21 matching lines @@
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
         manager, this, surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
       DLOG(ERROR) << "Failed to create surface.";
       return false;
     }
   }
 
-  scoped_refptr<gfx::GLContext> context;
-  gfx::GLShareGroup* gl_share_group = channel_->share_group();
+  scoped_refptr<gl::GLContext> context;
+  gl::GLShareGroup* gl_share_group = channel_->share_group();
   if (use_virtualized_gl_context_ && gl_share_group) {
     context = gl_share_group->GetSharedContext();
     if (!context.get()) {
       context = gl::init::CreateGLContext(
           gl_share_group,
           manager->GetDefaultOffscreenSurface(),
           init_params.gpu_preference);
       if (!context.get()) {
         DLOG(ERROR) << "Failed to create shared context for virtualization.";
         return false;
       }
       // Ensure that context creation did not lose track of the intended
       // gl_share_group.
       DCHECK(context->share_group() == gl_share_group);
       gl_share_group->SetSharedContext(context.get());
     }
     // This should be either:
     // (1) a non-virtual GL context, or
     // (2) a mock context.
     DCHECK(context->GetHandle() ||
-           gfx::GetGLImplementation() == gfx::kGLImplementationMockGL);
+           gl::GetGLImplementation() == gl::kGLImplementationMockGL);
     context = new GLContextVirtual(
         gl_share_group, context.get(), decoder_->AsWeakPtr());
     if (!context->Initialize(surface_.get(), init_params.gpu_preference)) {
       // The real context created above for the default offscreen surface
       // might not be compatible with this surface.
       context = NULL;
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       return false;
     }
   }
@@ skipping 490 matching lines @@
 
     // Work around issues with recovery by allowing a new GPU process to launch.
     if ((was_lost_by_robustness ||
          context_group_->feature_info()->workarounds().exit_on_context_lost)) {
       channel_->gpu_channel_manager()->MaybeExitOnContextLost();
     }
 
     // Lose all other contexts if the reset was triggered by the robustness
     // extension instead of being synthetic.
     if (was_lost_by_robustness &&
-        (gfx::GLContext::LosesAllContextsOnContextLost() ||
+        (gl::GLContext::LosesAllContextsOnContextLost() ||
          use_virtualized_gl_context_)) {
       channel_->LoseAllContexts();
     }
   }
 
   CheckCompleteWaits();
   return was_lost;
 }
 
 void GpuCommandBufferStub::MarkContextLost() {
@@ skipping 12 matching lines @@
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, params));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace gpu