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

gpu/ipc/service/image_transport_surface_overlay_mac.mm

 // Copyright 2015 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/image_transport_surface_overlay_mac.h"
 
 #include <CoreGraphics/CoreGraphics.h>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLTypes.h>
@@ skipping 39 matching lines @@
   }
 }
 
 void IOSurfaceContextNoOp(scoped_refptr<ui::IOSurfaceContext>) {
 }
 
 }  // namespace
 
 namespace gpu {
 
-scoped_refptr<gfx::GLSurface> ImageTransportSurfaceCreateNativeSurface(
+scoped_refptr<gl::GLSurface> ImageTransportSurfaceCreateNativeSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     SurfaceHandle handle) {
   return new ImageTransportSurfaceOverlayMac(stub, handle);
 }
 
 ImageTransportSurfaceOverlayMac::ImageTransportSurfaceOverlayMac(
     GpuCommandBufferStub* stub,
     SurfaceHandle handle)
     : stub_(stub->AsWeakPtr()),
       handle_(handle),
       use_remote_layer_api_(ui::RemoteLayerAPISupported()),
       scale_factor_(1),
       gl_renderer_id_(0) {
   ui::GpuSwitchingManager::GetInstance()->AddObserver(this);
   ca_layer_tree_coordinator_.reset(
       new ui::CALayerTreeCoordinator(use_remote_layer_api_));
 }
 
 ImageTransportSurfaceOverlayMac::~ImageTransportSurfaceOverlayMac() {
   ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
   if (stub_.get()) {
     stub_->SetLatencyInfoCallback(
         base::Callback<void(const std::vector<ui::LatencyInfo>&)>());
   }
   Destroy();
 }
 
-bool ImageTransportSurfaceOverlayMac::Initialize(
-    gfx::GLSurface::Format format) {
+bool ImageTransportSurfaceOverlayMac::Initialize(gl::GLSurface::Format format) {
   if (!stub_.get() || !stub_->decoder())
     return false;
 
   stub_->SetLatencyInfoCallback(
       base::Bind(&ImageTransportSurfaceOverlayMac::SetLatencyInfo,
                  base::Unretained(this)));
 
   // Create the CAContext to send this to the GPU process, and the layer for
   // the context.
   if (use_remote_layer_api_) {
@@ skipping 28 matching lines @@
     gpu::SurfaceHandle surface_handle,
     CAContextID ca_context_id,
     bool fullscreen_low_power_ca_context_valid,
     CAContextID fullscreen_low_power_ca_context_id,
     const gfx::ScopedRefCountedIOSurfaceMachPort& io_surface,
     const gfx::Size& size,
     float scale_factor,
     std::vector<ui::LatencyInfo> latency_info) {
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffers", TRACE_EVENT_SCOPE_THREAD,
-                       "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
+                       "GLImpl", static_cast<int>(gl::GetGLImplementation()),
                        "width", size.width());
 
   GpuCommandBufferMsg_SwapBuffersCompleted_Params params;
   params.surface_handle = surface_handle;
   params.ca_context_id = ca_context_id;
   params.fullscreen_low_power_ca_context_valid =
       fullscreen_low_power_ca_context_valid;
   params.fullscreen_low_power_ca_context_id =
       fullscreen_low_power_ca_context_id;
   params.io_surface = io_surface;
   params.pixel_size = size;
   params.scale_factor = scale_factor;
   params.latency_info = std::move(latency_info);
   params.result = gfx::SwapResult::SWAP_ACK;
   stub_->SendSwapBuffersCompleted(params);
 }
 
 gfx::SwapResult ImageTransportSurfaceOverlayMac::SwapBuffersInternal(
     const gfx::Rect& pixel_damage_rect) {
   TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::SwapBuffersInternal");
 
   // A glFlush is necessary to ensure correct content appears. A glFinish
   // appears empirically to be the best way to get maximum performance when
   // GPU bound.
   {
-    gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
+    gl::ScopedSetGLToRealGLApi scoped_set_gl_api;
     TRACE_EVENT0("gpu", "ImageTransportSurfaceOverlayMac::glFinish");
     CheckGLErrors("Before finish");
     glFinish();
     CheckGLErrors("After finish");
   }
 
   base::TimeTicks finish_time = base::TimeTicks::Now();
 
   bool fullscreen_low_power_layer_valid = false;
   ca_layer_tree_coordinator_->CommitPendingTreesToCA(
@@ skipping 51 matching lines @@
 }
 
 gfx::Size ImageTransportSurfaceOverlayMac::GetSize() {
   return gfx::Size();
 }
 
 void* ImageTransportSurfaceOverlayMac::GetHandle() {
   return nullptr;
 }
 
-bool ImageTransportSurfaceOverlayMac::OnMakeCurrent(gfx::GLContext* context) {
+bool ImageTransportSurfaceOverlayMac::OnMakeCurrent(gl::GLContext* context) {
   // Ensure that the context is on the appropriate GL renderer. The GL renderer
   // will generally only change when the GPU changes.
   if (gl_renderer_id_ && context)
     context->share_group()->SetRendererID(gl_renderer_id_);
   return true;
 }
 
 bool ImageTransportSurfaceOverlayMac::ScheduleOverlayPlane(
     int z_order,
     gfx::OverlayTransform transform,
@@ skipping 69 matching lines @@
   gl_renderer_id_ = context_renderer_id & kCGLRendererIDMatchingMask;
 
   // Post a task holding a reference to the new GL context. The reason for
   // this is to avoid creating-then-destroying the context for every image
   // transport surface that is observing the GPU switch.
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&IOSurfaceContextNoOp, context_on_new_gpu));
 }
 
 }  // namespace gpu