ui/gl: Move GLImage into gl namespace.

content/common/gpu/media/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 "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 66 matching lines @@
       texture_manager->GetTexture(picture_buffer.internal_texture_id());
   RETURN_NULL_IF_NULL(texture_ref);
 
   return texture_ref;
 }
 
 AVDACodecImage* AndroidDeferredRenderingBackingStrategy::GetImageForPicture(
     const media::PictureBuffer& picture_buffer) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_NULL_IF_NULL(texture_ref);
-  gfx::GLImage* image =
+  gl::GLImage* image =
       texture_ref->texture()->GetLevelImage(GetTextureTarget(), 0);
   return static_cast<AVDACodecImage*>(image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
     const media::PictureBuffer& picture_buffer,
-    const scoped_refptr<gfx::GLImage>& image) {
+    const scoped_refptr<gl::GLImage>& image) {
   gpu::gles2::TextureRef* texture_ref = GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
   gpu::gles2::TextureManager* texture_manager =
       state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
   RETURN_IF_NULL(texture_manager);
 
   if (image) {
     // Also set the parameters for the level if we're not clearing
     // the image.
@@ skipping 22 matching lines @@
   // Note that this is not a race, since we do not re-use a PictureBuffer
   // until after the CC is done drawing it.
   avImage->SetMediaCodecBufferIndex(codec_buf_index);
   avImage->SetSize(state_provider_->GetSize());
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
-  scoped_refptr<gfx::GLImage> gl_image(
+  scoped_refptr<gl::GLImage> gl_image(
       new AVDACodecImage(shared_state_, media_codec_,
                          state_provider_->GetGlDecoder(), surface_texture_));
   SetImageForPicture(picture_buffer, gl_image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBufferForPicture(
     const media::PictureBuffer& picture_buffer) {
   AVDACodecImage* avImage = GetImageForPicture(picture_buffer);
 
   // See if there is a media codec buffer still attached to this image.
@@ skipping 37 matching lines @@
   // doesn't know about them.
   media_codec_ = codec;
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
     AVDACodecImage* avImage = GetImageForPicture(entry.second);
     avImage->SetMediaCodec(codec);
     avImage->SetMediaCodecBufferIndex(-1);
   }
 }
 
 }  // namespace content