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

media/gpu/android_deferred_rendering_backing_strategy.cc

 // 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 "media/gpu/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
@@ skipping 19 matching lines @@
 
 namespace media {
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy(AVDAStateProvider* state_provider)
     : state_provider_(state_provider), media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
-gfx::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
+gl::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
     int surface_view_id) {
   shared_state_ = new AVDASharedState();
 
   // Create a texture for the SurfaceTexture to use.
   GLuint service_id;
   glGenTextures(1, &service_id);
+  DCHECK(service_id);
   shared_state_->set_surface_texture_service_id(service_id);
 
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_EXTERNAL_OES, service_id);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   state_provider_->GetGlDecoder()->RestoreTextureUnitBindings(0);
   state_provider_->GetGlDecoder()->RestoreActiveTexture();
   DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
-  gfx::ScopedJavaSurface surface;
+  gl::ScopedJavaSurface surface;
   if (surface_view_id != media::VideoDecodeAccelerator::Config::kNoSurfaceID) {
     surface = gpu::GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(
         surface_view_id);
   } else {
     bool using_virtual_context = false;
-    if (gfx::GLContext* context = gfx::GLContext::GetCurrent()) {
-      if (gfx::GLShareGroup* share_group = context->share_group())
+    if (gl::GLContext* context = gl::GLContext::GetCurrent()) {
+      if (gl::GLShareGroup* share_group = context->share_group())
         using_virtual_context = !!share_group->GetSharedContext();
     }
     UMA_HISTOGRAM_BOOLEAN("Media.AVDA.VirtualContext", using_virtual_context);
     // Detach doesn't work so well on all platforms.  Just attach the
     // SurfaceTexture here, and probably context switch later.
     // Detaching might save us a context switch, since AVDACodecImage will
     // attach when needed.  However, given that it also fails a lot, we just
     // don't do it at all.  If virtual contexts are in use, then it doesn't
     // even save us a context switch.
-    surface_texture_ = gfx::SurfaceTexture::Create(service_id);
+    surface_texture_ = gl::SurfaceTexture::Create(service_id);
     shared_state_->DidAttachSurfaceTexture();
-    surface = gfx::ScopedJavaSurface(surface_texture_.get());
+    surface = gl::ScopedJavaSurface(surface_texture_.get());
   }
 
   return surface;
 }
 
 void AndroidDeferredRenderingBackingStrategy::Cleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
@@ skipping 11 matching lines @@
   if (surface_texture_ && have_context && ShouldCopyPictures())
     CopySurfaceTextureToPictures(buffers);
 
   // Now that no AVDACodecImages refer to the SurfaceTexture's texture, delete
   // the texture name.
   GLuint service_id = shared_state_->surface_texture_service_id();
   if (service_id > 0 && have_context)
     glDeleteTextures(1, &service_id);
 }
 
-scoped_refptr<gfx::SurfaceTexture>
+scoped_refptr<gl::SurfaceTexture>
 AndroidDeferredRenderingBackingStrategy::GetSurfaceTexture() const {
   return surface_texture_;
 }
 
 uint32_t AndroidDeferredRenderingBackingStrategy::GetTextureTarget() const {
   // If we're using a surface texture, then we need an external texture target
   // to sample from it.  If not, then we'll use 2D transparent textures to draw
   // a transparent hole through which to see the SurfaceView.  This is normally
   // needed only for the devtools inspector, since the overlay mechanism handles
   // it otherwise.
@@ skipping 226 matching lines @@
   gpu::gles2::GLES2Decoder* gl_decoder = state_provider_->GetGlDecoder().get();
   if (!gl_decoder)
     return;
 
   const gfx::Size size = state_provider_->GetSize();
 
   // Create a 2D texture to hold a copy of the SurfaceTexture's front buffer.
   GLuint tmp_texture_id;
   glGenTextures(1, &tmp_texture_id);
   {
-    gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, tmp_texture_id);
+    gl::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, tmp_texture_id);
     // The target texture's size will exactly match the source.
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
   }
 
   float transform_matrix[16];
   surface_texture_->GetTransformMatrix(transform_matrix);
 
   gpu::CopyTextureCHROMIUMResourceManager copier;
   copier.Initialize(
       gl_decoder,
       gl_decoder->GetContextGroup()->feature_info()->feature_flags());
   copier.DoCopyTextureWithTransform(gl_decoder, GL_TEXTURE_EXTERNAL_OES,
                                     shared_state_->surface_texture_service_id(),
                                     GL_TEXTURE_2D, tmp_texture_id, size.width(),
                                     size.height(), true, false, false,
                                     transform_matrix);
 
   // Create an EGLImage from the 2D texture we just copied into. By associating
   // the EGLImage with the PictureBuffer textures they will remain valid even
   // after we delete the 2D texture and EGLImage.
   const EGLImageKHR egl_image = eglCreateImageKHR(
-      gfx::GLSurfaceEGL::GetHardwareDisplay(), eglGetCurrentContext(),
+      gl::GLSurfaceEGL::GetHardwareDisplay(), eglGetCurrentContext(),
       EGL_GL_TEXTURE_2D_KHR, reinterpret_cast<EGLClientBuffer>(tmp_texture_id),
       nullptr /* attrs */);
 
   glDeleteTextures(1, &tmp_texture_id);
   DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
   if (egl_image == EGL_NO_IMAGE_KHR) {
     DLOG(ERROR) << "Failed creating EGLImage: " << ui::GetLastEGLErrorString();
     return;
   }
 
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
     gpu::gles2::TextureRef* texture_ref =
         state_provider_->GetTextureForPicture(entry.second);
     if (!texture_ref)
       continue;
-    gfx::ScopedTextureBinder texture_binder(
+    gl::ScopedTextureBinder texture_binder(
         GL_TEXTURE_EXTERNAL_OES, texture_ref->texture()->service_id());
     glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 
   EGLBoolean result =
-      eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), egl_image);
+      eglDestroyImageKHR(gl::GLSurfaceEGL::GetHardwareDisplay(), egl_image);
   if (result == EGL_FALSE) {
     DLOG(ERROR) << "Error destroying EGLImage: " << ui::GetLastEGLErrorString();
   }
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ShouldCopyPictures() const {
   // See if there's a workaround.
   if (gpu::gles2::GLES2Decoder* gl_decoder =
           state_provider_->GetGlDecoder().get()) {
     if (gpu::gles2::ContextGroup* group = gl_decoder->GetContextGroup()) {
@@ skipping 23 matching lines @@
           model.find("sm-t285") != std::string::npos ||
           model.find("sm-j320") != std::string::npos)
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace media