Addition of GL_CHROMIUM_copy_texture 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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 15 matching lines @@
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
@@ skipping 673 matching lines @@
     const void * data);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
     GLenum target,
     GLsizei width,
     GLsizei height,
     GLuint io_surface_id,
     GLuint plane);
 
+  void DoCopyTextureCHROMIUM(
+    GLenum target,
+    GLuint source_id,
+    GLuint target_id,
+    GLint level);
+
   // Wrapper for TexStorage2DEXT.
   void DoTexStorage2DEXT(
     GLenum target,
     GLint levels,
     GLenum internal_format,
     GLsizei width,
     GLsizei height);
 
   // Creates a ProgramInfo for the given program.
   ProgramManager::ProgramInfo* CreateProgramInfo(
@@ skipping 386 matching lines @@
   void DoVertexAttrib1f(GLuint index, GLfloat v0);
   void DoVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1);
   void DoVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2);
   void DoVertexAttrib4f(
       GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
   void DoVertexAttrib1fv(GLuint index, const GLfloat *v);
   void DoVertexAttrib2fv(GLuint index, const GLfloat *v);
   void DoVertexAttrib3fv(GLuint index, const GLfloat *v);
   void DoVertexAttrib4fv(GLuint index, const GLfloat *v);
 
+  // Wrapper for glViewport
+  void DoViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+
   // Wrapper for glUseProgram
   void DoUseProgram(GLuint program);
 
   // Wrapper for glValidateProgram.
   void DoValidateProgram(GLuint program_client_id);
 
   // Gets the number of values that will be returned by glGetXXX. Returns
   // false if pname is unknown.
   bool GetNumValuesReturnedForGLGet(GLenum pname, GLsizei* num_values);
 
@@ skipping 14 matching lines @@
   // errors caused by GL calls that it was not responsible for issuing.
   void ClearRealGLErrors();
 
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(GLuint max_vertex_accessed, GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       GLuint max_vertex_accessed, bool* simulated);
-  void RestoreStateForSimulatedAttrib0();
+  void RestoreStateForAttrib(GLuint attrib);
 
   // Returns true if textures were set.
   bool SetBlackTextureForNonRenderableTextures();
   void RestoreStateForNonRenderableTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
 
@@ skipping 145 matching lines @@
 
   // Util to help with GL.
   GLES2Util util_;
 
   // pack alignment as last set by glPixelStorei
   GLint pack_alignment_;
 
   // unpack alignment as last set by glPixelStorei
   GLint unpack_alignment_;
 
+  // unpack flip y as last set by glPixelStorei
+  bool unpack_flip_y_;
+
+  // unpack premultiply alpha as last set by glPixelStorei
+  bool unpack_premultiply_alpha_;
+
   // The currently bound array buffer. If this is 0 it is illegal to call
   // glVertexAttribPointer.
   BufferManager::BufferInfo::Ref bound_array_buffer_;
 
   // The currently bound element array buffer. If this is 0 it is illegal
   // to call glDrawElements.
   BufferManager::BufferInfo::Ref bound_element_array_buffer_;
 
   // Class that manages vertex attribs.
   scoped_ptr<VertexAttribManager> vertex_attrib_manager_;
@@ skipping 32 matching lines @@
   GLclampf clear_alpha_;
   GLboolean mask_red_;
   GLboolean mask_green_;
   GLboolean mask_blue_;
   GLboolean mask_alpha_;
   GLint clear_stencil_;
   GLuint mask_stencil_front_;
   GLuint mask_stencil_back_;
   GLclampf clear_depth_;
   GLboolean mask_depth_;
+  bool enable_cull_face_;
   bool enable_scissor_test_;
   bool enable_depth_test_;
   bool enable_stencil_test_;
   bool state_dirty_;
 
   // The program in use by glUseProgram
   ProgramManager::ProgramInfo::Ref current_program_;
 
   // The currently bound framebuffers
   FramebufferManager::FramebufferInfo::Ref bound_read_framebuffer_;
@@ skipping 83 matching lines @@
   bool compile_shader_always_succeeds_;
 
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
 
   typedef std::vector<GLES2DecoderImpl*> ChildList;
   ChildList children_;
 
+  scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
+
+  // Cached values of the currently assigned viewport dimensions.
+  GLint viewport_x_, viewport_y_;
+  GLsizei viewport_width_, viewport_height_;
+  GLsizei viewport_max_width_, viewport_max_height_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->CopyRealGLErrorsToWrapper();
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   decoder_->ClearRealGLErrors();
@@ skipping 323 matching lines @@
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   return new GLES2DecoderImpl(group);
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* group)
     : GLES2Decoder(),
       group_(group),
       error_bits_(0),
       pack_alignment_(4),
       unpack_alignment_(4),
+      unpack_flip_y_(false),
+      unpack_premultiply_alpha_(false),
       attrib_0_buffer_id_(0),
       attrib_0_buffer_matches_value_(true),
       attrib_0_size_(0),
       fixed_attrib_buffer_id_(0),
       fixed_attrib_buffer_size_(0),
       active_texture_unit_(0),
       clear_red_(0),
       clear_green_(0),
       clear_blue_(0),
       clear_alpha_(0),
       mask_red_(true),
       mask_green_(true),
       mask_blue_(true),
       mask_alpha_(true),
       clear_stencil_(0),
       mask_stencil_front_(-1),
       mask_stencil_back_(-1),
       clear_depth_(1.0f),
       mask_depth_(true),
+      enable_cull_face_(false),
       enable_scissor_test_(false),
       enable_depth_test_(false),
       enable_stencil_test_(false),
       state_dirty_(true),
       offscreen_target_color_format_(0),
       offscreen_target_depth_format_(0),
       offscreen_target_stencil_format_(0),
       offscreen_target_samples_(0),
       offscreen_target_buffer_preserved_(true),
       offscreen_saved_color_format_(0),
       stream_texture_manager_(NULL),
       back_buffer_color_format_(0),
       back_buffer_has_depth_(false),
       back_buffer_has_stencil_(false),
       teximage2d_faster_than_texsubimage2d_(true),
       bufferdata_faster_than_buffersubdata_(true),
       current_decoder_error_(error::kNoError),
       use_shader_translator_(true),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       tex_image_2d_failed_(false),
       frame_number_(0),
       has_arb_robustness_(false),
       reset_status_(GL_NO_ERROR),
       needs_mac_nvidia_driver_workaround_(false),
       needs_glsl_built_in_function_emulation_(false),
       force_webgl_glsl_validation_(false),
       derivatives_explicitly_enabled_(false),
-      compile_shader_always_succeeds_(false) {
+      compile_shader_always_succeeds_(false),
+      viewport_x_(0),
+      viewport_y_(0),
+      viewport_width_(0),
+      viewport_height_(0),
+      viewport_max_width_(0),
+      viewport_max_height_(0) {
   DCHECK(group);
 
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
   // The shader translator is used for WebGL even when running on EGL
   // because additional restrictions are needed (like only enabling
   // GL_OES_standard_derivatives on demand).  It is used for the unit
@@ skipping 61 matching lines @@
     return false;
   }
 
   if (!group_->Initialize(disallowed_features, allowed_extensions)) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because group "
                << "failed to initialize.";
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy();
     return false;
   }
+  CHECK_GL_ERROR();
 
+  copy_texture_CHROMIUM_.reset(new CopyTextureCHROMIUMResourceManager());
+  copy_texture_CHROMIUM_->Initialize();
   CHECK_GL_ERROR();
+
   disallowed_features_ = disallowed_features;
 
   vertex_attrib_manager_.reset(new VertexAttribManager());
   vertex_attrib_manager_->Initialize(group_->max_vertex_attribs());
 
   query_manager_.reset(new QueryManager(this, feature_info_->feature_flags(
       ).use_arb_occlusion_query2_for_occlusion_query_boolean));
 
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
@@ skipping 199 matching lines @@
         vendor_str && strstr(vendor_str, "NVIDIA");
     needs_glsl_built_in_function_emulation_ =
         vendor_str && (strstr(vendor_str, "ATI") || strstr(vendor_str, "AMD"));
 #endif
   }
 
   if (!InitializeShaderTranslator()) {
     return false;
   }
 
+  GLint viewport_params[4];
+  glGetIntegerv(GL_VIEWPORT, viewport_params);
+  viewport_x_ = viewport_params[0];
+  viewport_y_ = viewport_params[1];
+  viewport_width_ = viewport_params[2];
+  viewport_height_ = viewport_params[3];
+
+  glGetIntegerv(GL_MAX_VIEWPORT_DIMS, viewport_params);
+  viewport_max_width_ = viewport_params[0];
+  viewport_max_height_ = viewport_params[0];
+
   return true;
 }
 
 void GLES2DecoderImpl::UpdateCapabilities() {
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
   util_.set_num_shader_binary_formats(
       validators_->shader_binary_format.GetValues().size());
 }
 
@@ skipping 486 matching lines @@
   texture_units_.reset();
   bound_array_buffer_ = NULL;
   bound_element_array_buffer_ = NULL;
   current_query_ = NULL;
   current_program_ = NULL;
   bound_read_framebuffer_ = NULL;
   bound_draw_framebuffer_ = NULL;
   bound_renderbuffer_ = NULL;
 
   if (have_context) {
+    copy_texture_CHROMIUM_->Destroy();
+
     if (current_program_) {
       program_manager()->UnuseProgram(shader_manager(), current_program_);
       current_program_ = NULL;
     }
 
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
     if (fixed_attrib_buffer_id_) {
       glDeleteBuffersARB(1, &fixed_attrib_buffer_id_);
@@ skipping 30 matching lines @@
       offscreen_target_stencil_render_buffer_->Invalidate();
     if (offscreen_saved_frame_buffer_.get())
       offscreen_saved_frame_buffer_->Invalidate();
     if (offscreen_saved_color_texture_.get())
       offscreen_saved_color_texture_->Invalidate();
     if (offscreen_resolved_frame_buffer_.get())
       offscreen_resolved_frame_buffer_->Invalidate();
     if (offscreen_resolved_color_texture_.get())
       offscreen_resolved_color_texture_->Invalidate();
   }
+  copy_texture_CHROMIUM_.reset();
 
   if (query_manager_.get()) {
     query_manager_->Destroy(have_context);
     query_manager_.reset();
   }
 
   if (group_) {
     group_->Destroy(have_context);
     group_ = NULL;
   }
@@ skipping 444 matching lines @@
     glColorMask(
         mask_red_, mask_green_, mask_blue_,
         mask_alpha_ && BoundFramebufferHasColorAttachmentWithAlpha());
     bool have_depth = BoundFramebufferHasDepthAttachment();
     glDepthMask(mask_depth_ && have_depth);
     EnableDisable(GL_DEPTH_TEST, enable_depth_test_ && have_depth);
     bool have_stencil = BoundFramebufferHasStencilAttachment();
     glStencilMaskSeparate(GL_FRONT, have_stencil ? mask_stencil_front_ : 0);
     glStencilMaskSeparate(GL_BACK, have_stencil ? mask_stencil_back_ : 0);
     EnableDisable(GL_STENCIL_TEST, enable_stencil_test_ && have_stencil);
+    EnableDisable(GL_CULL_FACE, enable_cull_face_);
+    EnableDisable(GL_SCISSOR_TEST, enable_scissor_test_);
     state_dirty_ = false;
   }
 }
 
 GLuint GLES2DecoderImpl::GetBackbufferServiceId() {
   return (offscreen_target_frame_buffer_.get()) ?
       offscreen_target_frame_buffer_->id() :
       surface_->GetBackingFrameBufferObject();
 }
 
@@ skipping 790 matching lines @@
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachRenderbuffer(attachment, info);
   }
   if (framebuffer_info == bound_draw_framebuffer_) {
     state_dirty_ = true;
   }
 }
 
 bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
+    case GL_CULL_FACE:
+      enable_cull_face_ = enabled;
+      return true;
     case GL_SCISSOR_TEST:
       enable_scissor_test_ = enabled;
       return true;
     case GL_DEPTH_TEST: {
       if (enable_depth_test_ != enabled) {
         enable_depth_test_ = enabled;
         state_dirty_ = true;
       }
       return false;
     }
@@ skipping 968 matching lines @@
 
   glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
 
   if (info->divisor())
     glVertexAttribDivisorANGLE(0, 0);
 
   *simulated = true;
   return true;
 }
 
-void GLES2DecoderImpl::RestoreStateForSimulatedAttrib0() {
+void GLES2DecoderImpl::RestoreStateForAttrib(GLuint attrib) {
   const VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(0);
+      vertex_attrib_manager_->GetVertexAttribInfo(attrib);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
   BufferManager::BufferInfo* buffer_info = info->buffer();
   glBindBuffer(GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
   glVertexAttribPointer(
-      0, info->size(), info->type(), info->normalized(), info->gl_stride(),
+      attrib, info->size(), info->type(), info->normalized(), info->gl_stride(),
       ptr);
   if (info->divisor())
-    glVertexAttribDivisorANGLE(0, info->divisor());
+    glVertexAttribDivisorANGLE(attrib, info->divisor());
   glBindBuffer(GL_ARRAY_BUFFER,
                bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
+
+  if (info->enabled()) {
+    glEnableVertexAttribArray(attrib);
+  } else {
+    glDisableVertexAttribArray(attrib);
+  }
 }
 
 bool GLES2DecoderImpl::SimulateFixedAttribs(
     GLuint max_vertex_accessed, bool* simulated, GLsizei primcount) {
   DCHECK(simulated);
   *simulated = false;
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
   if (!vertex_attrib_manager_->HaveFixedAttribs()) {
@@ skipping 152 matching lines @@
       }
       ProcessPendingQueries();
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
-      RestoreStateForSimulatedAttrib0();
+      RestoreStateForAttrib(0);
     }
     if (WasContextLost()) {
       LOG(ERROR) << "  GLES2DecoderImpl: Context lost during DrawArrays.";
       return error::kLostContext;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(
@@ skipping 90 matching lines @@
       }
       ProcessPendingQueries();
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
-      RestoreStateForSimulatedAttrib0();
+      RestoreStateForAttrib(0);
     }
     if (WasContextLost()) {
       LOG(ERROR) << "  GLES2DecoderImpl: Context lost during DrawElements.";
       return error::kLostContext;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElements(
@@ skipping 619 matching lines @@
       normalized,
       stride,
       stride != 0 ? stride : component_size * size,
       offset);
   if (type != GL_FIXED) {
     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   }
   return error::kNoError;
 }
 
+void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
+                                  GLsizei height) {
+  viewport_x_ = x;
+  viewport_y_ = y;
+  viewport_width_ = std::min(width, viewport_max_width_);
+  viewport_height_ = std::min(height, viewport_max_height_);
+  glViewport(x, y, width, height);
+}
+
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
     uint32 immediate_data_size, const gles2::VertexAttribDivisorANGLE& c) {
   if (!feature_info_->feature_flags().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
                "glVertexAttribDivisorANGLE: function not available");
   }
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
@@ skipping 178 matching lines @@
   glPixelStorei(pname, param);
   switch (pname) {
   case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
   case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
       break;
   case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
       break;
+  case GL_UNPACK_FLIP_Y_CHROMIUM:
+      unpack_flip_y_ = (param != 0);
+      break;
+  case GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM:
+      unpack_premultiply_alpha_ = (param != 0);
+      break;
   default:
       // Validation should have prevented us from getting here.
       NOTREACHED();
       break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
     uint32 immediate_data_size, const gles2::PostSubBufferCHROMIUM& c) {
@@ skipping 2064 matching lines @@
       return GL_LUMINANCE;
     case GL_LUMINANCE_ALPHA16F_EXT:
       return GL_LUMINANCE_ALPHA;
     case GL_BGRA8_EXT:
       return GL_BGRA_EXT;
     default:
       return GL_NONE;
   }
 }
 
+void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
+    GLenum target, GLuint source_id, GLuint dest_id, GLint level) {
+  TextureManager::TextureInfo* dest_info = GetTextureInfo(dest_id);
+  TextureManager::TextureInfo* source_info = GetTextureInfo(source_id);
+
+  if (!source_info || !dest_info) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTextureCHROMIUM: unknown texture id");
+    return;
+  }
+
+  if (GL_TEXTURE_2D != target) {
+    SetGLError(GL_INVALID_VALUE,
+               "glCopyTextureCHROMIUM: invalid texture target");
+    return;
+  }
+
+  int source_width, source_height, dest_width, dest_height;
+  if (!source_info->GetLevelSize(GL_TEXTURE_2D, 0, &source_width,
+                                 &source_height)) {
+    SetGLError(GL_INVALID_VALUE,
+               "glCopyTextureChromium: source texture has no level 0");
+    return;
+  }
+
+  if (!dest_info->GetLevelSize(GL_TEXTURE_2D, level, &dest_width,
+                               &dest_height)) {
+    SetGLError(GL_INVALID_VALUE,
+        "glCopyTextureChromium: destination texture level does not exist");
+    return;
+  }
+
+  // Check that this type of texture is allowed.
+  if (!texture_manager()->ValidForTarget(GL_TEXTURE_2D, level, source_width,
+                                         source_height, 1)) {
+    SetGLError(GL_INVALID_VALUE,
+             "glCopyTextureCHROMIUM: Bad dimensions");
+    return;
+  }
+
+  // Resize the destination texture to the dimensions of the source texture.
+  if (dest_width != source_width && dest_height != source_height) {
+    GLenum type;
+    GLenum internal_format;
+    dest_info->GetLevelType(GL_TEXTURE_2D, level, &type, &internal_format);
+
+    // Ensure that the glTexImage2D succeeds.
+    CopyRealGLErrorsToWrapper();
+    WrappedTexImage2D(
+        GL_TEXTURE_2D, level, internal_format, source_width, source_height,
+        0, internal_format, type, NULL);
+    GLenum error = PeekGLError();
+    if (error != GL_NO_ERROR)
+      return;
+
+    texture_manager()->SetLevelInfo(
+        dest_info, GL_TEXTURE_2D, level, internal_format, source_width,
+        source_height, 1, 0, internal_format, type, true);
+  }
+
+  state_dirty_ = true;
+  glViewport(0, 0, dest_width, dest_height);
+  copy_texture_CHROMIUM_->DoCopyTexture(target, source_info->service_id(),
+                                        dest_info->service_id(), level,
+                                        unpack_flip_y_,
+                                        unpack_premultiply_alpha_);
+  glViewport(viewport_x_, viewport_y_, viewport_width_, viewport_height_);
+
+  // Restore all of the state touched by the extension.
+  if (current_program_)
+    glUseProgram(current_program_->service_id());
+  else
+    glUseProgram(0);
+
+  RestoreCurrentFramebufferBindings();
+  RestoreCurrentTexture2DBindings();
+  RestoreStateForAttrib(
+      CopyTextureCHROMIUMResourceManager::kVertexPositionAttrib);
+  RestoreStateForAttrib(
+      CopyTextureCHROMIUMResourceManager::kVertexTextureAttrib);
+
+  ApplyDirtyState();
+}
+
 static GLenum ExtractTypeFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
     case GL_RGB565:
       return GL_UNSIGNED_SHORT_5_6_5;
     case GL_RGBA4:
       return GL_UNSIGNED_SHORT_4_4_4_4;
     case GL_RGB5_A1:
       return GL_UNSIGNED_SHORT_5_5_5_1;
     case GL_RGB8_OES:
       return GL_UNSIGNED_BYTE;
@@ skipping 77 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu