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

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 110 matching lines @@
       // These values are for an IEEE single-precision floating-point format.
       range[0] = 127;
       range[1] = 127;
       *precision = 23;
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
-      gfx::g_driver_gl.fn.glGetShaderPrecisionFormatFn) {
+  if (gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2 &&
+      gl::g_driver_gl.fn.glGetShaderPrecisionFormatFn) {
     // This function is sometimes defined even though it's really just
     // a stub, so we need to set range and precision as if it weren't
     // defined before calling it.
     // On Mac OS with some GPUs, calling this generates a
     // GL_INVALID_OPERATION error. Avoid calling it on non-GLES2
     // platforms.
     glGetShaderPrecisionFormat(shader_type, precision_type,
                                range, precision);
 
     // TODO(brianderson): Make the following official workarounds.
@@ skipping 365 matching lines @@
     return id_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(BackFramebuffer);
 };
 
 struct FenceCallback {
-  FenceCallback()
-      : fence(gfx::GLFence::Create()) {
-    DCHECK(fence);
-  }
+  FenceCallback() : fence(gl::GLFence::Create()) { DCHECK(fence); }
   std::vector<base::Closure> callbacks;
-  std::unique_ptr<gfx::GLFence> fence;
+  std::unique_ptr<gl::GLFence> fence;
 };
 
 // }  // anonymous namespace.
 
 // static
 const unsigned int GLES2Decoder::kDefaultStencilMask =
     static_cast<unsigned int>(-1);
 
 bool GLES2Decoder::GetServiceTextureId(uint32_t client_texture_id,
                                        uint32_t* service_texture_id) {
@@ skipping 39 matching lines @@
   template <bool DebugImpl>
   error::Error DoCommandsImpl(unsigned int num_commands,
                               const void* buffer,
                               int num_entries,
                               int* entries_processed);
 
   // Overridden from AsyncAPIInterface.
   const char* GetCommandName(unsigned int command_id) const override;
 
   // Overridden from GLES2Decoder.
-  bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
-                  const scoped_refptr<gfx::GLContext>& context,
+  bool Initialize(const scoped_refptr<gl::GLSurface>& surface,
+                  const scoped_refptr<gl::GLContext>& context,
                   bool offscreen,
                   const gfx::Size& offscreen_size,
                   const DisallowedFeatures& disallowed_features,
                   const ContextCreationAttribHelper& attrib_helper) override;
   void Destroy(bool have_context) override;
-  void SetSurface(const scoped_refptr<gfx::GLSurface>& surface) override;
+  void SetSurface(const scoped_refptr<gl::GLSurface>& surface) override;
   void ReleaseSurface() override;
   void TakeFrontBuffer(const Mailbox& mailbox) override;
   void ReturnFrontBuffer(const Mailbox& mailbox, bool is_lost) override;
   bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
   void UpdateParentTextureInfo();
   bool MakeCurrent() override;
   GLES2Util* GetGLES2Util() override { return &util_; }
-  gfx::GLContext* GetGLContext() override { return context_.get(); }
+  gl::GLContext* GetGLContext() override { return context_.get(); }
   ContextGroup* GetContextGroup() override { return group_.get(); }
   Capabilities GetCapabilities() override;
   void RestoreState(const ContextState* prev_state) override;
 
   void RestoreActiveTexture() const override { state_.RestoreActiveTexture(); }
   void RestoreAllTextureUnitBindings(
       const ContextState* prev_state) const override {
     state_.RestoreAllTextureUnitBindings(prev_state);
   }
   void RestoreActiveTextureUnitBinding(unsigned int target) const override {
@@ skipping 1386 matching lines @@
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
-  scoped_refptr<gfx::GLSurface> surface_;
-  scoped_refptr<gfx::GLContext> context_;
+  scoped_refptr<gl::GLSurface> surface_;
+  scoped_refptr<gl::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
   scoped_refptr<ContextGroup> group_;
 
   DebugMarkerManager debug_marker_manager_;
   Logger logger_;
 
   // All the state for this context.
   ContextState state_;
 
@@ skipping 731 matching lines @@
       validation_fbo_(0),
       texture_manager_service_id_generation_(0),
       force_shader_name_hashing_for_test(false) {
   DCHECK(group);
 }
 
 GLES2DecoderImpl::~GLES2DecoderImpl() {
 }
 
 bool GLES2DecoderImpl::Initialize(
-    const scoped_refptr<gfx::GLSurface>& surface,
-    const scoped_refptr<gfx::GLContext>& context,
+    const scoped_refptr<gl::GLSurface>& surface,
+    const scoped_refptr<gl::GLContext>& context,
     bool offscreen,
     const gfx::Size& offscreen_size,
     const DisallowedFeatures& disallowed_features,
     const ContextCreationAttribHelper& attrib_helper) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::Initialize");
   DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
   DCHECK(!offscreen || !offscreen_size.IsEmpty());
 
   surfaceless_ = surface->IsSurfaceless() && !offscreen;
@@ skipping 153 matching lines @@
       // glGetIntegerv() throws a GL error, it leaves its argument unchanged.
       GLint max_sample_count = 1;
       glGetIntegerv(GL_MAX_SAMPLES_EXT, &max_sample_count);
       offscreen_target_samples_ = std::min(attrib_helper.samples,
                                            max_sample_count);
     } else {
       offscreen_target_samples_ = 1;
     }
     offscreen_target_buffer_preserved_ = attrib_helper.buffer_preserved;
 
-    if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
+    if (gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2) {
       const bool rgb8_supported =
           context_->HasExtension("GL_OES_rgb8_rgba8");
       // The only available default render buffer formats in GLES2 have very
       // little precision.  Don't enable multisampling unless 8-bit render
       // buffer formats are available--instead fall back to 8-bit textures.
       if (rgb8_supported && offscreen_target_samples_ > 1) {
         offscreen_target_color_format_ = attrib_helper.alpha_size > 0 ?
             GL_RGBA8 : GL_RGB8;
       } else {
         offscreen_target_samples_ = 1;
@@ skipping 1426 matching lines @@
 
 #if defined(OS_MACOSX)
   for (TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.begin();
        it != texture_to_io_surface_map_.end(); ++it) {
     CFRelease(it->second);
   }
   texture_to_io_surface_map_.clear();
 #endif
 }
 
-void GLES2DecoderImpl::SetSurface(
-    const scoped_refptr<gfx::GLSurface>& surface) {
+void GLES2DecoderImpl::SetSurface(const scoped_refptr<gl::GLSurface>& surface) {
   DCHECK(context_->IsCurrent(NULL));
   DCHECK(surface);
   surface_ = surface;
   RestoreCurrentFramebufferBindings();
 }
 
 void GLES2DecoderImpl::ReleaseSurface() {
   if (!context_.get())
     return;
   if (WasContextLost()) {
@@ skipping 1269 matching lines @@
             (feature_info_->context_type() == CONTEXT_TYPE_WEBGL1 ||
              feature_info_->context_type() == CONTEXT_TYPE_OPENGLES2)) {
           *params = GL_HALF_FLOAT_OES;
         }
       }
       return true;
     default:
       break;
   }
 
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+  if (gl::GetGLImplementation() != gl::kGLImplementationEGLGLES2) {
     switch (pname) {
       case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_fragment_uniform_vectors();
         }
         return true;
       case GL_MAX_VARYING_VECTORS:
         *num_written = 1;
         if (params) {
@@ skipping 7462 matching lines @@
   // TODO(gman): call glShaderBinary
   return error::kNoError;
 #endif
 }
 
 void GLES2DecoderImpl::DoSwapBuffers() {
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
 
   int this_frame_number = frame_number_++;
   // TRACE_EVENT for gpu tests:
-  TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffersLatency",
-                       TRACE_EVENT_SCOPE_THREAD,
-                       "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
-                       "width", (is_offscreen ? offscreen_size_.width() :
-                                 surface_->GetSize().width()));
+  TRACE_EVENT_INSTANT2(
+      "test_gpu", "SwapBuffersLatency", TRACE_EVENT_SCOPE_THREAD, "GLImpl",
+      static_cast<int>(gl::GetGLImplementation()), "width",
+      (is_offscreen ? offscreen_size_.width() : surface_->GetSize().width()));
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoSwapBuffers",
                "offscreen", is_offscreen,
                "frame", this_frame_number);
   {
     TRACE_EVENT_SYNTHETIC_DELAY("gpu.PresentingFrame");
   }
 
   ScopedGPUTrace scoped_gpu_trace(gpu_tracer_.get(), kTraceDecoder,
                                   "GLES2Decoder", "SwapBuffer");
 
@@ skipping 907 matching lines @@
     CFRelease(surface);
     texture_to_io_surface_map_.erase(it);
   }
 }
 #endif
 
 void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
     GLenum target, GLsizei width, GLsizei height,
     GLuint io_surface_id, GLuint plane) {
 #if defined(OS_MACOSX)
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
+  if (gl::GetGLImplementation() != gl::kGLImplementationDesktopGL) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "only supported on desktop GL.");
     return;
   }
 
   if (target != GL_TEXTURE_RECTANGLE_ARB) {
     // This might be supported in the future, and if we could require
     // support for binding an IOSurface to a NPOT TEXTURE_2D texture, we
     // could delete a lot of code. For now, perform strict validation so we
@@ skipping 2733 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu