Support level > 0 for CopyTextureCHROMIUM extension

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 2006 matching lines @@
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
     GLsizei width, GLsizei height, GLsizei depth, GLenum format,
     Texture* texture);
   bool ValidateCopyTextureCHROMIUMTextures(const char* function_name,
                                            TextureRef* source_texture_ref,
                                            TextureRef* dest_texture_ref);
   CopyTextureMethod ValidateCopyTextureCHROMIUMInternalFormats(
       const char* function_name,
       TextureRef* source_texture_ref,
+      GLint source_level,
       GLenum dest_internal_format);
   bool ValidateCompressedCopyTextureCHROMIUM(const char* function_name,
                                              TextureRef* source_texture_ref,
                                              TextureRef* dest_texture_ref);
 
   void RenderWarning(const char* filename, int line, const std::string& msg);
   void PerformanceWarning(
       const char* filename, int line, const std::string& msg);
 
   const FeatureInfo::FeatureFlags& features() const {
@@ skipping 3518 matching lines @@
 
 void GLES2DecoderImpl::RestoreRenderbufferBindings() {
   state_.RestoreRenderbufferBindings();
 }
 
 void GLES2DecoderImpl::RestoreTextureState(unsigned service_id) const {
   Texture* texture = texture_manager()->GetTextureForServiceId(service_id);
   if (texture) {
     GLenum target = texture->target();
     glBindTexture(target, service_id);
-    glTexParameteri(
-        target, GL_TEXTURE_WRAP_S, texture->wrap_s());
-    glTexParameteri(
-        target, GL_TEXTURE_WRAP_T, texture->wrap_t());
-    glTexParameteri(
-        target, GL_TEXTURE_MIN_FILTER, texture->min_filter());
-    glTexParameteri(
-        target, GL_TEXTURE_MAG_FILTER, texture->mag_filter());
+    glTexParameteri(target, GL_TEXTURE_WRAP_S, texture->wrap_s());
+    glTexParameteri(target, GL_TEXTURE_WRAP_T, texture->wrap_t());
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, texture->min_filter());
+    glTexParameteri(target, GL_TEXTURE_MAG_FILTER, texture->mag_filter());
+    if (feature_info_->IsWebGL2OrES3Context()) {
+      glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, texture->base_level());
+    }
     RestoreTextureUnitBindings(state_.active_texture_unit);
   }
 }
 
 void GLES2DecoderImpl::ClearAllAttributes() const {
   // Must use native VAO 0, as RestoreAllAttributes can't fully restore
   // other VAOs.
   if (feature_info_->feature_flags().native_vertex_array_object)
     glBindVertexArrayOES(0);
 
@@ skipping 10600 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
                        "invalid source texture target binding");
     return false;
   }
   return true;
 }
 
 CopyTextureMethod GLES2DecoderImpl::ValidateCopyTextureCHROMIUMInternalFormats(
     const char* function_name,
     TextureRef* source_texture_ref,
+    GLint source_level,
     GLenum dest_internal_format) {
   GLenum source_type = 0;
   GLenum source_internal_format = 0;
   Texture* source_texture = source_texture_ref->texture();
-  source_texture->GetLevelType(source_texture->target(), 0, &source_type,
-                               &source_internal_format);
+  source_texture->GetLevelType(source_texture->target(), source_level,
+                               &source_type, &source_internal_format);
 
   bool valid_dest_format = false;
   // TODO(qiankun.miao@intel.com): ALPHA, LUMINANCE and LUMINANCE_ALPHA formats
   // are not supported on GL core profile. See crbug.com/577144. Enable the
   // workaround for glCopyTexImage and glCopyTexSubImage in
   // gles2_cmd_copy_tex_image.cc for glCopyTextureCHROMIUM implementation.
   switch (dest_internal_format) {
     case GL_RGB:
     case GL_RGBA:
     case GL_RGB8:
@@ skipping 143 matching lines @@
     GLuint dest_id,
     GLint dest_level,
     GLenum internal_format,
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
   static const char kFunctionName[] = "glCopyTextureCHROMIUM";
 
-  // TODO(qiankun.miao@intel.com): Remove this after level > 0 support is
-  // implemented. See: https://crbug.com/612542.
-  DCHECK(source_level == 0);
-  DCHECK(dest_level == 0);
-
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
 
   if (!ValidateCopyTextureCHROMIUMTextures(kFunctionName, source_texture_ref,
                                            dest_texture_ref)) {
     return;
   }
 
+  if (source_level < 0 || dest_level < 0 ||
+      (feature_info_->IsWebGL1OrES2Context() && source_level > 0)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
+                       "source_level or dest_level out of range");
+    return;
+  }
+
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   GLenum source_target = source_texture->target();
   GLenum dest_target = dest_texture->target();
 
   GLenum source_type = 0;
   GLenum source_internal_format = 0;
-  source_texture->GetLevelType(source_target, 0, &source_type,
+  source_texture->GetLevelType(source_target, source_level, &source_type,
                                &source_internal_format);
   GLenum format =
       TextureManager::ExtractFormatFromStorageFormat(internal_format);
   if (!texture_manager()->ValidateTextureParameters(
           GetErrorState(), kFunctionName, true, format, dest_type,
-          internal_format, 0)) {
+          internal_format, dest_level)) {
     return;
   }
 
   CopyTextureMethod method = ValidateCopyTextureCHROMIUMInternalFormats(
-      kFunctionName, source_texture_ref, internal_format);
+      kFunctionName, source_texture_ref, source_level, internal_format);
   // INVALID_OPERATION is already generated by
   // ValidateCopyTextureCHROMIUMInternalFormats.
-  if (NOT_COPYABLE == method) {
+  if (method == NOT_COPYABLE) {
     return;
   }
 
+  // Draw to a fbo attaching level 0 of an intermediate texture,
+  // then copy from the fbo to dest texture level with glCopyTexImage2D.
+  // For WebGL 1.0 or OpenGL ES 2.0, DIRECT_DRAW path isn't available for
+  // dest_level > 0 due to level > 0 isn't supported by glFramebufferTexture2D
+  // in ES2 context. Go to DRAW_AND_COPY path in this case.
+  // TODO(qiankun.miao@intel.com): for WebGL 2.0 or OpenGL ES 3.0, both
+  // DIRECT_DRAW path for dest_level > 0 and DIRECT_COPY path for source_level >
+  // 0 are not available due to a framebuffer completeness bug:
+  // crbug.com/678526. Once the bug is fixed, the limitation for WebGL 2.0 and
+  // OpenGL ES 3.0 can be lifted.
+  if ((dest_level > 0 && method == DIRECT_DRAW) ||
+      (source_level > 0 && method == DIRECT_COPY)) {
+    method = DRAW_AND_COPY;
+  }

[qiankun, 2017/01/14 00:23:24]

See the comments here. The current implementation doesn't reply on framebuffer
completeness. I just set TEXTURE_BASE_LEVEL and do sampling from that base
level. So it should be no problem. 

Zhenyao, can I land the CL as-is?

+
   if (feature_info_->feature_flags().desktop_srgb_support) {
     bool enable_framebuffer_srgb =
         GetColorEncodingFromInternalFormat(source_internal_format) == GL_SRGB ||
         GetColorEncodingFromInternalFormat(internal_format) == GL_SRGB;
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
   }
 
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
-      source_texture->GetLevelImage(source_target, 0);
+      source_texture->GetLevelImage(source_target, source_level);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_VALUE,
-          "glCopyTextureChromium", "invalid image size");
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "invalid image size");
       return;
     }
   } else {
-    if (!source_texture->GetLevelSize(source_target, 0,
+    if (!source_texture->GetLevelSize(source_target, source_level,
                                       &source_width, &source_height, nullptr)) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
-                         "glCopyTextureChromium",
-                         "source texture has no level 0");
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
+                         "source texture has no data for level");
       return;
     }
 
     // Check that this type of texture is allowed.
-    if (!texture_manager()->ValidForTarget(source_target, 0,
+    if (!texture_manager()->ValidForTarget(source_target, source_level,
                                            source_width, source_height, 1)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "Bad dimensions");
       return;
     }
   }
 
   if (dest_texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "texture is immutable");
     return;
   }
 
   // Clear the source texture if necessary.
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
-                                            source_target, 0)) {
+                                            source_target, source_level)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName, "dimensions too big");
     return;
   }
 
   if (!InitializeCopyTextureCHROMIUM(kFunctionName))
     return;
 
   GLenum dest_type_previous = dest_type;
   GLenum dest_internal_format = internal_format;
   int dest_width = 0;
   int dest_height = 0;
   bool dest_level_defined = dest_texture->GetLevelSize(
-      dest_target, 0, &dest_width, &dest_height, nullptr);
+      dest_target, dest_level, &dest_width, &dest_height, nullptr);
 
   if (dest_level_defined) {
-    dest_texture->GetLevelType(dest_target, 0, &dest_type_previous,
+    dest_texture->GetLevelType(dest_target, dest_level, &dest_type_previous,
                                &dest_internal_format);
   }
 
   // Resize the destination texture to the dimensions of the source texture.
   if (!dest_level_defined || dest_width != source_width ||
       dest_height != source_height ||
       dest_internal_format != internal_format ||
       dest_type_previous != dest_type) {
     // Ensure that the glTexImage2D succeeds.
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
     glBindTexture(dest_target, dest_texture->service_id());
-    glTexImage2D(dest_target, 0, TextureManager::AdjustTexInternalFormat(
-                                     feature_info_.get(), internal_format),
+    glTexImage2D(dest_target, dest_level,
+                 TextureManager::AdjustTexInternalFormat(feature_info_.get(),
+                                                         internal_format),
                  source_width, source_height, 0,
                  TextureManager::AdjustTexFormat(feature_info_.get(), format),
-                 dest_type, NULL);
+                 dest_type, nullptr);
     GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
     if (error != GL_NO_ERROR) {
       RestoreCurrentTextureBindings(&state_, dest_target);
       return;
     }
 
-    texture_manager()->SetLevelInfo(dest_texture_ref, dest_target, 0,
+    texture_manager()->SetLevelInfo(dest_texture_ref, dest_target, dest_level,
                                     internal_format, source_width,
                                     source_height, 1, 0, format, dest_type,
                                     gfx::Rect(source_width, source_height));
     dest_texture->ApplyFormatWorkarounds(feature_info_.get());
   } else {
-    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target, 0, true);
+    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target,
+                                       dest_level, true);
   }
 
   // Try using GLImage::CopyTexImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
-  if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
+  // TODO(qiankun.miao@intel.com): Support level > 0 for CopyTexImage.
+  if (image && dest_level == 0 && !unpack_flip_y &&
+      !unpack_premultiply_alpha_change) {
     glBindTexture(dest_target, dest_texture->service_id());
     if (image->CopyTexImage(dest_target))
       return;
   }
 
   DoCopyTexImageIfNeeded(source_texture, source_target);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires that we apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
-                                                       0)) {
+                                                       source_level)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
-          this, source_target, source_texture->service_id(),
+          this, source_target, source_texture->service_id(), source_level,
           source_internal_format, dest_target, dest_texture->service_id(),
-          internal_format, source_width, source_height,
+          dest_level, internal_format, source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
     }
   }
 
   copy_texture_CHROMIUM_->DoCopyTexture(
-      this, source_target, source_texture->service_id(), source_internal_format,
-      dest_target, dest_texture->service_id(), internal_format, source_width,
-      source_height, unpack_flip_y == GL_TRUE,
-      unpack_premultiply_alpha == GL_TRUE, unpack_unmultiply_alpha == GL_TRUE,
-      method);
+      this, source_target, source_texture->service_id(), source_level,
+      source_internal_format, dest_target, dest_texture->service_id(),
+      dest_level, internal_format, source_width, source_height,
+      unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
+      unpack_unmultiply_alpha == GL_TRUE, method);
 }
 
 void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(
     GLuint source_id,
     GLint source_level,
     GLuint dest_id,
     GLint dest_level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopySubTextureCHROMIUM");
 
-  // TODO(qiankun.miao@intel.com): Remove this after level > 0 support is
-  // implemented. See: https://crbug.com/612542.
-  DCHECK(source_level == 0);
-  DCHECK(dest_level == 0);
-
   static const char kFunctionName[] = "glCopySubTextureCHROMIUM";
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
 
   if (!ValidateCopyTextureCHROMIUMTextures(kFunctionName, source_texture_ref,
                                            dest_texture_ref)) {
     return;
   }
 
+  if (source_level < 0 || dest_level < 0 ||
+      (feature_info_->IsWebGL1OrES2Context() && source_level > 0)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
+                       "source_level or dest_level out of range");
+    return;
+  }
+
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   GLenum source_target = source_texture->target();
   GLenum dest_target = dest_texture->target();
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
-      source_texture->GetLevelImage(source_target, 0);
+      source_texture->GetLevelImage(source_target, source_level);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "invalid image size");
       return;
     }
 
     // Ideally we should not need to check that the sub-texture copy rectangle
     // is valid in two different ways, here and below. However currently there
     // is no guarantee that a texture backed by a GLImage will have sensible
     // level info. If this synchronization were to be enforced then this and
     // other functions in this file could be cleaned up.
     // See: https://crbug.com/586476
     int32_t max_x;
     int32_t max_y;
     if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y) ||
         x < 0 || y < 0 || max_x > source_width || max_y > source_height) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                          "source texture bad dimensions");
       return;
     }
   } else {
-    if (!source_texture->GetLevelSize(source_target, 0,
+    if (!source_texture->GetLevelSize(source_target, source_level,
                                       &source_width, &source_height, nullptr)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
-                         "source texture has no level 0");
+                         "source texture has no data for level");
       return;
     }
 
     // Check that this type of texture is allowed.
-    if (!texture_manager()->ValidForTarget(source_target, 0,
+    if (!texture_manager()->ValidForTarget(source_target, source_level,
                                            source_width, source_height, 1)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                          "source texture bad dimensions");
       return;
     }
 
-    if (!source_texture->ValidForTexture(source_target, 0, x, y, 0, width,
-                                         height, 1)) {
+    if (!source_texture->ValidForTexture(source_target, source_level, x, y, 0,
+                                         width, height, 1)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                          "source texture bad dimensions.");
       return;
     }
   }
 
   GLenum source_type = 0;
   GLenum source_internal_format = 0;
-  source_texture->GetLevelType(source_target, 0, &source_type,
+  source_texture->GetLevelType(source_target, source_level, &source_type,
                                &source_internal_format);
 
   GLenum dest_type = 0;
   GLenum dest_internal_format = 0;
   bool dest_level_defined = dest_texture->GetLevelType(
-      dest_target, 0, &dest_type, &dest_internal_format);
+      dest_target, dest_level, &dest_type, &dest_internal_format);
   if (!dest_level_defined) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "destination texture is not defined");
     return;
   }
-  if (!dest_texture->ValidForTexture(dest_target, 0, xoffset,
-                                     yoffset, 0, width, height, 1)) {
+  if (!dest_texture->ValidForTexture(dest_target, dest_level, xoffset, yoffset,
+                                     0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                        "destination texture bad dimensions.");
     return;
   }
 
   CopyTextureMethod method = ValidateCopyTextureCHROMIUMInternalFormats(
-      kFunctionName, source_texture_ref, dest_internal_format);
+      kFunctionName, source_texture_ref, source_level, dest_internal_format);
   // INVALID_OPERATION is already generated by
   // ValidateCopyTextureCHROMIUMInternalFormats.
-  if (NOT_COPYABLE == method) {
+  if (method == NOT_COPYABLE) {
     return;
   }
 
+  // Draw to a fbo attaching level 0 of an intermediate texture,
+  // then copy from the fbo to dest texture level with glCopyTexImage2D.
+  // For WebGL 1.0 or OpenGL ES 2.0, DIRECT_DRAW path isn't available for
+  // dest_level > 0 due to level > 0 isn't supported by glFramebufferTexture2D
+  // in ES2 context. Go to DRAW_AND_COPY path in this case.
+  // TODO(qiankun.miao@intel.com): for WebGL 2.0 or OpenGL ES 3.0, both
+  // DIRECT_DRAW path for dest_level > 0 and DIRECT_COPY path for source_level >
+  // 0 are not available due to a framebuffer completeness bug:
+  // crbug.com/678526. Once the bug is fixed, the limitation for WebGL 2.0 and
+  // OpenGL ES 3.0 can be lifted.
+  if ((dest_level > 0 && method == DIRECT_DRAW) ||
+      (source_level > 0 && method == DIRECT_COPY)) {
+    method = DRAW_AND_COPY;
+  }
+
   if (feature_info_->feature_flags().desktop_srgb_support) {
     bool enable_framebuffer_srgb =
         GetColorEncodingFromInternalFormat(source_internal_format) == GL_SRGB ||
         GetColorEncodingFromInternalFormat(dest_internal_format) == GL_SRGB;
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
   }
 
   // Clear the source texture if necessary.
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
-                                            source_target, 0)) {
+                                            source_target, source_level)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName,
                        "source texture dimensions too big");
     return;
   }
 
   if (!InitializeCopyTextureCHROMIUM(kFunctionName))
     return;
 
   int dest_width = 0;
   int dest_height = 0;
-  bool ok = dest_texture->GetLevelSize(
-      dest_target, 0, &dest_width, &dest_height, nullptr);
+  bool ok = dest_texture->GetLevelSize(dest_target, dest_level, &dest_width,
+                                       &dest_height, nullptr);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 || width != dest_width ||
       height != dest_height) {
     gfx::Rect cleared_rect;
     if (TextureManager::CombineAdjacentRects(
-            dest_texture->GetLevelClearedRect(dest_target, 0),
+            dest_texture->GetLevelClearedRect(dest_target, dest_level),
             gfx::Rect(xoffset, yoffset, width, height), &cleared_rect)) {
-      DCHECK_GE(
-          cleared_rect.size().GetArea(),
-          dest_texture->GetLevelClearedRect(dest_target, 0).size().GetArea());
-      texture_manager()->SetLevelClearedRect(dest_texture_ref, dest_target, 0,
-                                             cleared_rect);
+      DCHECK_GE(cleared_rect.size().GetArea(),
+                dest_texture->GetLevelClearedRect(dest_target, dest_level)
+                    .size()
+                    .GetArea());
+      texture_manager()->SetLevelClearedRect(dest_texture_ref, dest_target,
+                                             dest_level, cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!texture_manager()->ClearTextureLevel(this, dest_texture_ref,
-                                                dest_target, 0)) {
+                                                dest_target, dest_level)) {
         LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName,
                            "destination texture dimensions too big");
         return;
       }
     }
   } else {
-    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target, 0,
-                                       true);
+    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target,
+                                       dest_level, true);
   }
 
   // Try using GLImage::CopyTexSubImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
-  if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
+  // TODO(qiankun.miao@intel.com): Support level > 0 for CopyTexSubImage.
+  if (image && dest_level == 0 && !unpack_flip_y &&
+      !unpack_premultiply_alpha_change) {
     ScopedTextureBinder binder(
         &state_, dest_texture->service_id(), dest_target);
     if (image->CopyTexSubImage(dest_target, gfx::Point(xoffset, yoffset),
                                gfx::Rect(x, y, width, height))) {
       return;
     }
   }
 
   DoCopyTexImageIfNeeded(source_texture, source_target);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
-                                                       0)) {
+                                                       source_level)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopySubTextureWithTransform(
-          this, source_target, source_texture->service_id(),
+          this, source_target, source_texture->service_id(), source_level,
           source_internal_format, dest_target, dest_texture->service_id(),
-          dest_internal_format, xoffset, yoffset, x, y, width, height,
-          dest_width, dest_height, source_width, source_height,
+          dest_level, dest_internal_format, xoffset, yoffset, x, y, width,
+          height, dest_width, dest_height, source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
     }
   }
   copy_texture_CHROMIUM_->DoCopySubTexture(
-      this, source_target, source_texture->service_id(), source_internal_format,
-      dest_target, dest_texture->service_id(), dest_internal_format, xoffset,
-      yoffset, x, y, width, height, dest_width, dest_height, source_width,
-      source_height, unpack_flip_y == GL_TRUE,
-      unpack_premultiply_alpha == GL_TRUE, unpack_unmultiply_alpha == GL_TRUE,
-      method);
+      this, source_target, source_texture->service_id(), source_level,
+      source_internal_format, dest_target, dest_texture->service_id(),
+      dest_level, dest_internal_format, xoffset, yoffset, x, y, width, height,
+      dest_width, dest_height, source_width, source_height,
+      unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
+      unpack_unmultiply_alpha == GL_TRUE, method);
 }
 
 bool GLES2DecoderImpl::InitializeCopyTexImageBlitter(
     const char* function_name) {
   if (!copy_tex_image_blit_.get()) {
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
     copy_tex_image_blit_.reset(
         new CopyTexImageResourceManager(feature_info_.get()));
     copy_tex_image_blit_->Initialize(this);
     if (LOCAL_PEEK_GL_ERROR(function_name) != GL_NO_ERROR)
@@ skipping 151 matching lines @@
     RestoreCurrentTextureBindings(&state_, dest_texture->target());
     return;
   }
 
   texture_manager()->SetLevelInfo(
       dest_texture_ref, dest_texture->target(), 0, GL_RGBA, source_width,
       source_height, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       gfx::Rect(source_width, source_height));
 
   copy_texture_CHROMIUM_->DoCopyTexture(
-      this, source_texture->target(), source_texture->service_id(),
+      this, source_texture->target(), source_texture->service_id(), 0,
       source_internal_format, dest_texture->target(),
-      dest_texture->service_id(), GL_RGBA, source_width, source_height, false,
-      false, false, DIRECT_DRAW);
+      dest_texture->service_id(), 0, GL_RGBA, source_width, source_height,
+      false, false, false, DIRECT_DRAW);
 }
 
 void GLES2DecoderImpl::TexStorageImpl(GLenum target,
                                       GLsizei levels,
                                       GLenum internal_format,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth,
                                       ContextState::Dimension dimension,
                                       const char* function_name) {
@@ skipping 2231 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