Use GrGLTextureInfo for Skia texture handles.

media/renderers/skcanvas_video_renderer.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 "media/renderers/skcanvas_video_renderer.h"
 
 #include <limits>
 
 #include "base/macros.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "skia/ext/refptr.h"
+#include "skia/ext/texture_handle.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrPaint.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "third_party/skia/include/gpu/SkGr.h"
+#include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/skia_util.h"
 
 // Skia internal format depends on a platform. On Android it is ABGR, on others
 // it is ARGB.
 #if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
     SK_A32_SHIFT == 24
 #define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB
 #define LIBYUV_I422_TO_ARGB libyuv::I422ToARGB
 #define LIBYUV_I444_TO_ARGB libyuv::I444ToARGB
@@ skipping 53 matching lines @@
   DCHECK(video_frame->HasTextures());
   DCHECK_EQ(media::PIXEL_FORMAT_I420, video_frame->format());
   DCHECK_EQ(3u, media::VideoFrame::NumPlanes(video_frame->format()));
 
   gpu::gles2::GLES2Interface* gl = context_3d.gl;
   DCHECK(gl);
   gfx::Size ya_tex_size = video_frame->coded_size();
   gfx::Size uv_tex_size((ya_tex_size.width() + 1) / 2,
                         (ya_tex_size.height() + 1) / 2);
 
-  unsigned source_textures[3] = {0};
+  GrGLTextureInfo source_textures[] = {{0, 0}, {0, 0}, {0, 0}};
   for (size_t i = 0; i < media::VideoFrame::NumPlanes(video_frame->format());
        ++i) {
     // Get the texture from the mailbox and wrap it in a GrTexture.
     const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
     DCHECK(mailbox_holder.texture_target == GL_TEXTURE_2D ||
            mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES ||
            mailbox_holder.texture_target == GL_TEXTURE_RECTANGLE_ARB);
     gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
-    source_textures[i] = gl->CreateAndConsumeTextureCHROMIUM(
+    source_textures[i].fID = gl->CreateAndConsumeTextureCHROMIUM(
         mailbox_holder.texture_target, mailbox_holder.mailbox.name);
+    source_textures[i].fTarget = mailbox_holder.texture_target;
 
     // TODO(dcastagna): avoid this copy once Skia supports native textures
     // with a texture target different than TEXTURE_2D.
     // crbug.com/505026
     if (mailbox_holder.texture_target != GL_TEXTURE_2D) {
       unsigned texture_copy = 0;
       gl->GenTextures(1, &texture_copy);
       DCHECK(texture_copy);
       gl->BindTexture(GL_TEXTURE_2D, texture_copy);
-      gl->CopyTextureCHROMIUM(source_textures[i], texture_copy, GL_RGB,
+      gl->CopyTextureCHROMIUM(source_textures[i].fID, texture_copy, GL_RGB,
                               GL_UNSIGNED_BYTE, false, true, false);
 
-      gl->DeleteTextures(1, &source_textures[i]);
-      source_textures[i] = texture_copy;
+      gl->DeleteTextures(1, &source_textures[i].fID);
+      source_textures[i].fID = texture_copy;
+      source_textures[i].fTarget = GL_TEXTURE_2D;
     }
   }
-  DCHECK_LE(source_textures[0],
-            static_cast<unsigned>(std::numeric_limits<int>::max()));
-  DCHECK_LE(source_textures[1],
-            static_cast<unsigned>(std::numeric_limits<int>::max()));
-  DCHECK_LE(source_textures[2],
-            static_cast<unsigned>(std::numeric_limits<int>::max()));
-  GrBackendObject handles[3] = {static_cast<int>(source_textures[0]),
-                                static_cast<int>(source_textures[1]),
-                                static_cast<int>(source_textures[2])};
+  GrBackendObject handles[3] = {
+      skia::GrGLTextureInfoToGrBackendObject(source_textures[0]),
+      skia::GrGLTextureInfoToGrBackendObject(source_textures[1]),
+      skia::GrGLTextureInfoToGrBackendObject(source_textures[2])};
 
   SkISize yuvSizes[] = {
       {ya_tex_size.width(), ya_tex_size.height()},
       {uv_tex_size.width(), uv_tex_size.height()},
       {uv_tex_size.width(), uv_tex_size.height()},
   };
 
   SkYUVColorSpace color_space = kRec601_SkYUVColorSpace;
   if (CheckColorSpace(video_frame, media::COLOR_SPACE_JPEG))
     color_space = kJPEG_SkYUVColorSpace;
   else if (CheckColorSpace(video_frame, media::COLOR_SPACE_HD_REC709))
     color_space = kRec709_SkYUVColorSpace;
 
   SkImage* img = SkImage::NewFromYUVTexturesCopy(context_3d.gr_context,
                                                  color_space, handles, yuvSizes,
                                                  kTopLeft_GrSurfaceOrigin);
-  gl->DeleteTextures(3, source_textures);
+  for (size_t i = 0; i < media::VideoFrame::NumPlanes(video_frame->format());
+       ++i) {
+    gl->DeleteTextures(1, &source_textures[i].fID);
+  }
   return skia::AdoptRef(img);
 }
 
 // Creates a SkImage from a |video_frame| backed by native resources.
 // The SkImage will take ownership of the underlying resource.
 skia::RefPtr<SkImage> NewSkImageFromVideoFrameNative(
     VideoFrame* video_frame,
     const Context3D& context_3d) {
   DCHECK(PIXEL_FORMAT_ARGB == video_frame->format() ||
          PIXEL_FORMAT_XRGB == video_frame->format() ||
@@ skipping 22 matching lines @@
     gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
     source_texture = gl->CreateAndConsumeTextureCHROMIUM(
         mailbox_holder.texture_target, mailbox_holder.mailbox.name);
   }
   GrBackendTextureDesc desc;
   desc.fFlags = kRenderTarget_GrBackendTextureFlag;
   desc.fOrigin = kTopLeft_GrSurfaceOrigin;
   desc.fWidth = video_frame->coded_size().width();
   desc.fHeight = video_frame->coded_size().height();
   desc.fConfig = kRGBA_8888_GrPixelConfig;
-  DCHECK_LE(source_texture,
-            static_cast<unsigned>(std::numeric_limits<int>::max()));
-  desc.fTextureHandle = static_cast<int>(source_texture);
+  GrGLTextureInfo source_texture_info;
+  source_texture_info.fID = source_texture;
+  source_texture_info.fTarget = GL_TEXTURE_2D;
+  desc.fTextureHandle =
+      skia::GrGLTextureInfoToGrBackendObject(source_texture_info);
   return skia::AdoptRef(
       SkImage::NewFromAdoptedTexture(context_3d.gr_context, desc));
 }
 
 }  // anonymous namespace
 
 // Generates an RGB image from a VideoFrame. Convert YUV to RGB plain on GPU.
 class VideoImageGenerator : public SkImageGenerator {
  public:
   VideoImageGenerator(const scoped_refptr<VideoFrame>& frame)
@@ skipping 453 matching lines @@
 }
 
 void SkCanvasVideoRenderer::ResetCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Clear cached values.
   last_image_ = nullptr;
   last_timestamp_ = kNoTimestamp();
 }
 
 }  // namespace media