Revert of ui: Move GLImage::BindTexImage fallback from GLImage implementations to GLES2CmdDecoder.

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 <cmath>
@@ skipping 621 matching lines @@
                                            bool enforce_internal_framebuffer,
                                            bool internal);
   ~ScopedResolvedFrameBufferBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
   bool resolve_and_bind_;
   DISALLOW_COPY_AND_ASSIGN(ScopedResolvedFrameBufferBinder);
 };
 
+class ScopedModifyPixels {
+ public:
+  explicit ScopedModifyPixels(TextureRef* ref);
+  ~ScopedModifyPixels();
+
+ private:
+  TextureRef* ref_;
+};
+
+ScopedModifyPixels::ScopedModifyPixels(TextureRef* ref) : ref_(ref) {
+  if (ref_)
+    ref_->texture()->OnWillModifyPixels();
+}
+
+ScopedModifyPixels::~ScopedModifyPixels() {
+  if (ref_)
+    ref_->texture()->OnDidModifyPixels();
+}
+
+class ScopedRenderTo {
+ public:
+  explicit ScopedRenderTo(Framebuffer* framebuffer)
+      : ScopedRenderTo(framebuffer, 0) {}
+  ScopedRenderTo(Framebuffer* framebuffer, GLenum attachment);
+  ~ScopedRenderTo();
+
+ private:
+  const Framebuffer* framebuffer_;
+  GLenum attachment_;
+};
+
+ScopedRenderTo::ScopedRenderTo(Framebuffer* framebuffer, GLenum attachment)
+    : framebuffer_(framebuffer),
+      attachment_(attachment) {
+  if (framebuffer_)
+    framebuffer_->OnWillRenderTo(attachment_);
+}
+
+ScopedRenderTo::~ScopedRenderTo() {
+  if (framebuffer_)
+    framebuffer_->OnDidRenderTo(attachment_);
+}
+
 // Encapsulates an OpenGL texture.
 class BackTexture {
  public:
   explicit BackTexture(MemoryTracker* memory_tracker, ContextState* state);
   ~BackTexture();
 
   // Create a new render texture.
   void Create();
 
   // Set the initial size and format of a render texture or resize it.
@@ skipping 132 matching lines @@
 
 GLES2Decoder::~GLES2Decoder() {
 }
 
 void GLES2Decoder::BeginDecoding() {}
 
 void GLES2Decoder::EndDecoding() {}
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
-class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
+class GLES2DecoderImpl : public GLES2Decoder,
+                         public FramebufferManager::TextureDetachObserver,
+                         public ErrorStateClient {
  public:
   explicit GLES2DecoderImpl(ContextGroup* group);
   ~GLES2DecoderImpl() override;
 
   // Overridden from AsyncAPIInterface.
   Error DoCommand(unsigned int command,
                   unsigned int arg_count,
                   const void* args) override;
 
   error::Error DoCommands(unsigned int num_commands,
@@ skipping 108 matching lines @@
 
   // These check the state of the currently bound framebuffer or the
   // backbuffer if no framebuffer is bound.
   // Check with all attached and enabled color attachments.
   bool BoundFramebufferHasColorAttachmentWithAlpha();
   bool BoundFramebufferHasDepthAttachment();
   bool BoundFramebufferHasStencilAttachment();
 
   error::ContextLostReason GetContextLostReason() override;
 
+  // Overridden from FramebufferManager::TextureDetachObserver:
+  void OnTextureRefDetachedFromFramebuffer(TextureRef* texture) override;
+
   // Overriden from ErrorStateClient.
   void OnContextLostError() override;
   void OnOutOfMemoryError() override;
 
   // Ensure Renderbuffer corresponding to last DoBindRenderbuffer() is bound.
   void EnsureRenderbufferBound();
 
   // Helpers to facilitate calling into compatible extensions.
   static void RenderbufferStorageMultisampleHelper(
       const FeatureInfo* feature_info,
@@ skipping 981 matching lines @@
   bool IsDrawValid(
       const char* function_name, GLuint max_vertex_accessed, bool instanced,
       GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib, bool restore_array_binding);
 
-  // Copies the image to the texture currently bound to |textarget|. The image
-  // state of |texture| is updated to reflect the new state.
-  void DoCopyTexImage(Texture* texture, GLenum textarget, gfx::GLImage* image);
-
-  // This will call DoCopyTexImage if texture has an image but that image is
-  // not bound or copied to the texture.
-  void DoCopyTexImageIfNeeded(Texture* texture, GLenum textarget);
+  // If an image is bound to texture, this will call Will/DidUseTexImage
+  // if needed.
+  void DoWillUseTexImageIfNeeded(Texture* texture, GLenum textarget);
+  void DoDidUseTexImageIfNeeded(Texture* texture, GLenum textarget);
 
   // Returns false if textures were replaced.
   bool PrepareTexturesForRender();
   void RestoreStateForTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
       const char* function_name,
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
@@ skipping 1299 matching lines @@
   }
 
   if (workarounds().gl_clear_broken) {
     DCHECK(!clear_framebuffer_blit_.get());
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glClearWorkaroundInit");
     clear_framebuffer_blit_.reset(new ClearFramebufferResourceManager(this));
     if (LOCAL_PEEK_GL_ERROR("glClearWorkaroundInit") != GL_NO_ERROR)
       return false;
   }
 
+  framebuffer_manager()->AddObserver(this);
+
   return true;
 }
 
 Capabilities GLES2DecoderImpl::GetCapabilities() {
   DCHECK(initialized());
   Capabilities caps;
   caps.VisitPrecisions([](GLenum shader, GLenum type,
                           Capabilities::ShaderPrecision* shader_precision) {
     GLint range[2] = {0, 0};
     GLint precision = 0;
@@ skipping 1079 matching lines @@
   fragment_translator_ = NULL;
   vertex_translator_ = NULL;
 
   // Destroy the GPU Tracer which may own some in process GPU Timings.
   if (gpu_tracer_) {
     gpu_tracer_->Destroy(have_context);
     gpu_tracer_.reset();
   }
 
   if (group_.get()) {
+    framebuffer_manager()->RemoveObserver(this);
     group_->Destroy(this, have_context);
     group_ = NULL;
   }
 
   if (context_.get()) {
     context_->ReleaseCurrent(NULL);
     context_ = NULL;
   }
 
 #if defined(OS_MACOSX)
@@ skipping 823 matching lines @@
           attachment = GL_STENCIL_ATTACHMENT;
           break;
         default:
           NOTREACHED();
           return;
       }
     }
     translated_attachments[i] = attachment;
   }
 
+  ScopedRenderTo do_render(framebuffer);
   if (feature_info_->gl_version_info().is_es3) {
     glInvalidateFramebuffer(
         target, numAttachments, translated_attachments.get());
   } else {
     glDiscardFramebufferEXT(
         target, numAttachments, translated_attachments.get());
   }
 }
 
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
@@ skipping 757 matching lines @@
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::DoClear(GLbitfield mask) {
   DCHECK(!ShouldDeferDraws());
   if (CheckBoundFramebuffersValid("glClear")) {
     ApplyDirtyState();
     // TODO(zmo): Filter out INTEGER/SIGNED INTEGER images to avoid
     // undefined results.
+    ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get());
     if (workarounds().gl_clear_broken) {
       ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::ClearWorkaround",
                                          GetErrorState());
       if (!BoundFramebufferHasDepthAttachment())
         mask &= ~GL_DEPTH_BUFFER_BIT;
       if (!BoundFramebufferHasStencilAttachment())
         mask &= ~GL_STENCIL_BUFFER_BIT;
       clear_framebuffer_blit_->ClearFramebuffer(
           this, GetBoundReadFrameBufferSize(), mask, state_.color_clear_red,
           state_.color_clear_green, state_.color_clear_blue,
@@ skipping 13 matching lines @@
 
   switch (buffer) {
     case GL_COLOR:
     case GL_STENCIL:
       break;
     default:
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glClearBufferiv", "invalid buffer");
       return;
   }
+  GLenum attachment = 0;
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferiv", "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (!GLES2Util::IsSignedIntegerFormat(internal_format)) {
       // To avoid undefined results, return without calling the gl function.
       return;
     }
+    attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer);
   } else {
     DCHECK(buffer == GL_STENCIL);
     if (drawbuffer != 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferiv", "invalid drawBuffer");
       return;
     }
     if (!BoundFramebufferHasStencilAttachment()) {
       return;
     }
+    attachment = GL_STENCIL_ATTACHMENT;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferiv(buffer, drawbuffer, value);
+  {
+    ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get(),
+                             attachment);
+    glClearBufferiv(buffer, drawbuffer, value);
+  }
 }
 
 void GLES2DecoderImpl::DoClearBufferuiv(
     GLenum buffer, GLint drawbuffer, const GLuint* value) {
   if (!CheckBoundDrawFramebufferValid("glClearBufferuiv"))
     return;
   ApplyDirtyState();
 
   switch (buffer) {
     case GL_COLOR:
       break;
     default:
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glClearBufferuiv", "invalid buffer");
       return;
   }
   if (drawbuffer < 0 ||
       drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glClearBufferuiv", "invalid drawBuffer");
     return;
   }
   GLenum internal_format =
       GetBoundColorDrawBufferInternalFormat(drawbuffer);
   if (!GLES2Util::IsUnsignedIntegerFormat(internal_format)) {
     // To avoid undefined results, return without calling the gl function.
     return;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferuiv(buffer, drawbuffer, value);
+  GLenum attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer);
+  {
+    ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get(),
+                             attachment);
+    glClearBufferuiv(buffer, drawbuffer, value);
+  }
 }
 
 void GLES2DecoderImpl::DoClearBufferfv(
     GLenum buffer, GLint drawbuffer, const GLfloat* value) {
   if (!CheckBoundDrawFramebufferValid("glClearBufferfv"))
     return;
   ApplyDirtyState();
 
   switch (buffer) {
     case GL_COLOR:
     case GL_DEPTH:
       break;
     default:
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glClearBufferfv", "invalid buffer");
       return;
   }
+  GLenum attachment = 0;
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferfv", "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (GLES2Util::IsIntegerFormat(internal_format)) {
       // To avoid undefined results, return without calling the gl function.
       return;
     }
+    attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer);
   } else {
     DCHECK(buffer == GL_DEPTH);
     if (drawbuffer != 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glClearBufferfv", "invalid drawBuffer");
       return;
     }
     if (!BoundFramebufferHasDepthAttachment()) {
       return;
     }
+    attachment = GL_DEPTH_ATTACHMENT;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferfv(buffer, drawbuffer, value);
+  {
+    ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get(),
+                             attachment);
+    glClearBufferfv(buffer, drawbuffer, value);
+  }
 }
 
 void GLES2DecoderImpl::DoClearBufferfi(
     GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
   if (!CheckBoundDrawFramebufferValid("glClearBufferfi"))
     return;
   ApplyDirtyState();
 
   switch (buffer) {
     case GL_DEPTH_STENCIL:
       break;
     default:
       LOCAL_SET_GL_ERROR(
           GL_INVALID_ENUM, "glClearBufferfi", "invalid buffer");
       return;
   }
   if (drawbuffer != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glClearBufferfi", "invalid drawBuffer");
     return;
   }
   if (!BoundFramebufferHasDepthAttachment() &&
       !BoundFramebufferHasStencilAttachment()) {
     return;
   }
   MarkDrawBufferAsCleared(GL_DEPTH, drawbuffer);
   MarkDrawBufferAsCleared(GL_STENCIL, drawbuffer);
-  glClearBufferfi(buffer, drawbuffer, depth, stencil);
+  {
+    ScopedRenderTo do_render_depth(
+        framebuffer_state_.bound_draw_framebuffer.get(),
+        GL_DEPTH_ATTACHMENT);
+    ScopedRenderTo do_render_stencil(
+        framebuffer_state_.bound_draw_framebuffer.get(),
+        GL_STENCIL_ATTACHMENT);
+    glClearBufferfi(buffer, drawbuffer, depth, stencil);
+  }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glFramebufferRenderbuffer", "no framebuffer bound");
@@ skipping 190 matching lines @@
   }
 
   if (!texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         name, "level out of range");
     return;
   }
 
   if (texture_ref)
-    DoCopyTexImageIfNeeded(texture_ref->texture(), textarget);
+    DoWillUseTexImageIfNeeded(texture_ref->texture(), textarget);
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(name);
   if (0 == samples) {
     glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   } else {
     if (features().use_img_for_multisampled_render_to_texture) {
       glFramebufferTexture2DMultisampleIMG(target, attachment, textarget,
           service_id, level, samples);
     } else {
       glFramebufferTexture2DMultisampleEXT(target, attachment, textarget,
           service_id, level, samples);
     }
   }
   GLenum error = LOCAL_PEEK_GL_ERROR(name);
   if (error == GL_NO_ERROR) {
     framebuffer->AttachTexture(attachment, texture_ref, textarget, level,
          samples);
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
+  if (texture_ref)
+    DoDidUseTexImageIfNeeded(texture_ref->texture(), textarget);
+
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
     GLint level, GLint layer) {
   // TODO(zmo): Unsafe ES3 API, missing states update.
   GLuint service_id = 0;
   TextureRef* texture_ref = NULL;
   if (client_texture_id) {
@@ skipping 119 matching lines @@
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
     GLbitfield mask, GLenum filter) {
   DCHECK(!ShouldDeferReads() && !ShouldDeferDraws());
 
   if (!CheckBoundFramebuffersValid("glBlitFramebufferCHROMIUM")) {
     return;
   }
 
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+  ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get());
   BlitFramebufferHelper(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
 }
 
 void GLES2DecoderImpl::EnsureRenderbufferBound() {
   if (!state_.bound_renderbuffer_valid) {
     state_.bound_renderbuffer_valid = true;
     glBindRenderbufferEXT(GL_RENDERBUFFER,
@@ skipping 1039 matching lines @@
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line, std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line,
                      std::string("PERFORMANCE WARNING: ") + msg);
 }
 
-void GLES2DecoderImpl::DoCopyTexImage(Texture* texture,
-                                      GLenum textarget,
-                                      gfx::GLImage* image) {
-  // Note: We update the state to COPIED prior to calling CopyTexImage()
-  // as that allows the GLImage implemenatation to set it back to UNBOUND
-  // and ensure that CopyTexImage() is called each time the texture is
-  // used.
-  texture->SetLevelImage(textarget, 0, image, Texture::COPIED);
-  bool rv = image->CopyTexImage(textarget);
-  DCHECK(rv) << "Both BindTexImage() and CopyTexImage() failed";
-}
-
-void GLES2DecoderImpl::DoCopyTexImageIfNeeded(Texture* texture,
-                                              GLenum textarget) {
+void GLES2DecoderImpl::DoWillUseTexImageIfNeeded(
+    Texture* texture, GLenum textarget) {
   // Image is already in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
-    Texture::ImageState image_state;
-    gfx::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
-    if (image && image_state == Texture::UNBOUND) {
+    gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+    if (image) {
       ScopedGLErrorSuppressor suppressor(
-          "GLES2DecoderImpl::DoCopyTexImageIfNeeded", GetErrorState());
+          "GLES2DecoderImpl::DoWillUseTexImageIfNeeded",
+          GetErrorState());
       glBindTexture(textarget, texture->service_id());
-      DoCopyTexImage(texture, textarget, image);
+      image->WillUseTexImage();
       RestoreCurrentTextureBindings(&state_, textarget);
     }
   }
+}
+
+void GLES2DecoderImpl::DoDidUseTexImageIfNeeded(
+    Texture* texture, GLenum textarget) {
+  // Image is still in use if texture is attached to a framebuffer.
+  if (texture && !texture->IsAttachedToFramebuffer()) {
+    gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+    if (image) {
+      ScopedGLErrorSuppressor suppressor(
+          "GLES2DecoderImpl::DoDidUseTexImageIfNeeded",
+          GetErrorState());
+      glBindTexture(textarget, texture->service_id());
+      image->DidUseTexImage();
+      RestoreCurrentTextureBindings(&state_, textarget);
+    }
+  }
 }
 
 bool GLES2DecoderImpl::PrepareTexturesForRender() {
   DCHECK(state_.current_program.get());
   if (!texture_manager()->HaveUnrenderableTextures() &&
       !texture_manager()->HaveImages()) {
     return true;
   }
   bool textures_set = false;
   const Program::SamplerIndices& sampler_indices =
@@ skipping 24 matching lines @@
                 std::string("texture bound to texture unit ") +
                 base::UintToString(texture_unit_index) +
                 " is not renderable. It maybe non-power-of-2 and have"
                 " incompatible texture filtering.");
           }
           continue;
         }
 
         if (textarget != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
-          Texture::ImageState image_state;
-          gfx::GLImage* image =
-              texture->GetLevelImage(textarget, 0, &image_state);
-          if (image && image_state == Texture::UNBOUND &&
-              !texture->IsAttachedToFramebuffer()) {
+          gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+          if (image && !texture->IsAttachedToFramebuffer()) {
             ScopedGLErrorSuppressor suppressor(
                 "GLES2DecoderImpl::PrepareTexturesForRender", GetErrorState());
             textures_set = true;
             glActiveTexture(GL_TEXTURE0 + texture_unit_index);
-            DoCopyTexImage(texture, textarget, image);
+            image->WillUseTexImage();
             continue;
           }
         }
       }
       // else: should this be an error?
     }
   }
   return !textures_set;
 }
 
@@ skipping 14 matching lines @@
         if (!texture_ref || !texture_manager()->CanRender(texture_ref)) {
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           // Get the texture_ref info that was previously bound here.
           texture_ref = texture_unit.bind_target == GL_TEXTURE_2D
                             ? texture_unit.bound_texture_2d.get()
                             : texture_unit.bound_texture_cube_map.get();
           glBindTexture(texture_unit.bind_target,
                         texture_ref ? texture_ref->service_id() : 0);
           continue;
         }
+
+        if (texture_unit.bind_target != GL_TEXTURE_CUBE_MAP) {
+          Texture* texture = texture_ref->texture();
+          gfx::GLImage* image =
+              texture->GetLevelImage(texture_unit.bind_target, 0);
+          if (image && !texture->IsAttachedToFramebuffer()) {
+            ScopedGLErrorSuppressor suppressor(
+                "GLES2DecoderImpl::RestoreStateForTextures", GetErrorState());
+            glActiveTexture(GL_TEXTURE0 + texture_unit_index);
+            image->DidUseTexImage();
+            continue;
+          }
+        }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::ClearUnclearedTextures() {
   // Only check if there are some uncleared textures.
   if (!texture_manager()->HaveUnsafeTextures()) {
@@ skipping 335 matching lines @@
     if (!SimulateAttrib0(
         function_name, max_vertex_accessed, &simulated_attrib_0)) {
       return error::kNoError;
     }
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(
         function_name, max_vertex_accessed, &simulated_fixed_attribs,
         primcount)) {
       bool textures_set = !PrepareTexturesForRender();
       ApplyDirtyState();
+      ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get());
       if (!instanced) {
         glDrawArrays(mode, first, count);
       } else {
         glDrawArraysInstancedANGLE(mode, first, count, primcount);
       }
       if (textures_set) {
         RestoreStateForTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
@@ skipping 116 matching lines @@
       // TODO(gman): Refactor to hide these details in BufferManager or
       // VertexAttribManager.
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       bool used_client_side_array = false;
       if (element_array_buffer->IsClientSideArray()) {
         used_client_side_array = true;
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
         indices = element_array_buffer->GetRange(offset, 0);
       }
 
+      ScopedRenderTo do_render(framebuffer_state_.bound_draw_framebuffer.get());
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
       }
 
       if (used_client_side_array) {
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                      element_array_buffer->service_id());
       }
@@ skipping 1210 matching lines @@
     const void* cmd_data) {
   const gles2::cmds::ScheduleOverlayPlaneCHROMIUM& c =
       *static_cast<const gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(cmd_data);
   TextureRef* ref = texture_manager()->GetTexture(c.overlay_texture_id);
   if (!ref) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unknown texture");
     return error::kNoError;
   }
-  Texture::ImageState image_state;
   gfx::GLImage* image =
-      ref->texture()->GetLevelImage(ref->texture()->target(), 0, &image_state);
-  if (!image || image_state != Texture::BOUND) {
+      ref->texture()->GetLevelImage(ref->texture()->target(), 0);
+  if (!image) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unsupported texture format");
     return error::kNoError;
   }
   gfx::OverlayTransform transform = GetGFXOverlayTransform(c.plane_transform);
   if (transform == gfx::OVERLAY_TRANSFORM_INVALID) {
     LOCAL_SET_GL_ERROR(GL_INVALID_ENUM,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "invalid transform enum");
@@ skipping 1583 matching lines @@
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the rect.
     scoped_ptr<char[]> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
+    ScopedModifyPixels modify(texture_ref);
     glTexImage2D(target, level, internal_format, width, height, border,
                  format, type, zero.get());
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
+    ScopedModifyPixels modify(texture_ref);
     glCopyTexImage2D(target, level, internal_format,
                      copyX, copyY, copyWidth, copyHeight, border);
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, 1, border, format,
                                     type, gfx::Rect(width, height));
   }
 
@@ skipping 106 matching lines @@
     uint32 pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSizes(
         width, height, 1, format, type, state_.unpack_alignment, &pixels_size,
         NULL, NULL)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glCopyTexSubImage2D", "dimensions too large");
       return;
     }
     scoped_ptr<char[]> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
+    ScopedModifyPixels modify(texture_ref);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
     GLint dx = copyX - x;
     GLint dy = copyY - y;
     GLint destX = xoffset + dx;
     GLint destY = yoffset + dy;
+    ScopedModifyPixels modify(texture_ref);
     glCopyTexSubImage2D(target, level,
                         destX, destY, copyX, copyY,
                         copyWidth, copyHeight);
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
@@ skipping 1962 matching lines @@
 
     texture_manager()->SetLevelInfo(
         dest_texture_ref, GL_TEXTURE_2D, 0, internal_format, source_width,
         source_height, 1, 0, internal_format, dest_type,
         gfx::Rect(source_width, source_height));
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
-  // Try using GLImage::CopyTexImage when possible.
+  ScopedModifyPixels modify(dest_texture_ref);
+
+  // 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) {
     glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
-    if (image->CopyTexImage(GL_TEXTURE_2D))
+    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(0, 0),
+                               gfx::Rect(0, 0, source_width, source_height))) {
       return;
+    }
   }
 
-  DoCopyTexImageIfNeeded(source_texture, source_texture->target());
+  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {
     // TODO(hkuang): get the StreamTexture transform matrix in GPU process
     // instead of using kIdentityMatrix crbug.com/226218.
     copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
         this, source_texture->target(), source_texture->service_id(),
         dest_texture->service_id(), source_width, source_height,
         unpack_flip_y == GL_TRUE,
         unpack_premultiply_alpha == GL_TRUE,
         unpack_unmultiply_alpha == GL_TRUE,
         kIdentityMatrix);
   } else {
     copy_texture_CHROMIUM_->DoCopyTexture(
         this, source_texture->target(), source_texture->service_id(),
         source_internal_format, 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);
   }
+
+  DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(
     GLenum target,
     GLuint source_id,
     GLuint dest_id,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
@@ skipping 112 matching lines @@
         LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopySubTextureCHROMIUM",
                            "destination texture dimensions too big");
         return;
       }
     }
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
+  ScopedModifyPixels modify(dest_texture_ref);
+
   // 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) {
     ScopedTextureBinder binder(
         &state_, dest_texture->service_id(), GL_TEXTURE_2D);
     if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
                                gfx::Rect(x, y, width, height))) {
       return;
     }
   }
 
-  DoCopyTexImageIfNeeded(source_texture, source_texture->target());
+  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // TODO(hkuang): get the StreamTexture transform matrix in GPU process.
   // crbug.com/226218.
   copy_texture_CHROMIUM_->DoCopySubTexture(
       this, source_texture->target(), source_texture->service_id(),
       source_internal_format, 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);
+
+  DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 void GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM(GLenum target,
                                                        GLuint source_id,
                                                        GLuint dest_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
@@ skipping 65 matching lines @@
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
                                             source_texture->target(), 0)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCompressedCopyTextureCHROMIUM",
                        "dimensions too big");
     return;
   }
 
   ScopedTextureBinder binder(
       &state_, dest_texture->service_id(), GL_TEXTURE_2D);
 
+  ScopedModifyPixels modify(dest_texture_ref);
+
   // Try using GLImage::CopyTexImage when possible.
   if (image) {
     GLenum dest_type = 0;
     GLenum dest_internal_format = 0;
     int dest_width = 0;
     int dest_height = 0;
     bool dest_level_defined = dest_texture->GetLevelSize(
         GL_TEXTURE_2D, 0, &dest_width, &dest_height, nullptr);
 
     if (dest_level_defined) {
@@ skipping 25 matching lines @@
 
       texture_manager()->SetLevelInfo(
           dest_texture_ref, GL_TEXTURE_2D, 0, source_internal_format,
           source_width, source_height, 1, 0, source_internal_format,
           source_type, gfx::Rect(source_width, source_height));
     } else {
       texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                          true);
     }
 
-    if (image->CopyTexImage(GL_TEXTURE_2D))
+    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(0, 0),
+                               gfx::Rect(0, 0, source_width, source_height))) {
       return;
+    }
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
-  DoCopyTexImageIfNeeded(source_texture, source_texture->target());
+  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedCopyTextureCHROMIUM");
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, source_width, source_height,
                0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedCopyTextureCHROMIUM");
   if (error != GL_NO_ERROR) {
     RestoreCurrentTextureBindings(&state_, GL_TEXTURE_2D);
     return;
   }
@@ skipping 11 matching lines @@
     copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
         this, source_texture->target(), source_texture->service_id(),
         dest_texture->service_id(), source_width, source_height,
         false, false, false, kIdentityMatrix);
   } else {
     copy_texture_CHROMIUM_->DoCopyTexture(
         this, source_texture->target(), source_texture->service_id(),
         source_internal_format, dest_texture->service_id(), GL_RGBA,
         source_width, source_height, false, false, false);
   }
+
+  DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 void GLES2DecoderImpl::DoCompressedCopySubTextureCHROMIUM(GLenum target,
                                                           GLuint source_id,
                                                           GLuint dest_id,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLint x,
                                                           GLint y,
                                                           GLsizei width,
@@ skipping 128 matching lines @@
       }
     }
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
   ScopedTextureBinder binder(
       &state_, dest_texture->service_id(), GL_TEXTURE_2D);
 
+  ScopedModifyPixels modify(dest_texture_ref);
+
   // Try using GLImage::CopyTexSubImage when possible.
-  if (image &&
-      image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
-                             gfx::Rect(x, y, width, height))) {
-    return;
+  if (image) {
+    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
+                               gfx::Rect(x, y, width, height))) {
+      return;
+    }
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopySubTextureCHROMIUM, fallback");
 
-  DoCopyTexImageIfNeeded(source_texture, source_texture->target());
+  DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   if (dest_internal_format != GL_RGBA) {
     // To preserve the contents of the original destination texture we must
     // first copy the original destination texture to a temporary storage, then
     // copy it back to the original destination texture.
     GLuint tmp_service_id;
     glGenTextures(1, &tmp_service_id);
     DCHECK_NE(0u, tmp_service_id);
 
@@ skipping 32 matching lines @@
     glDeleteTextures(1, &tmp_service_id);
   }
 
   // TODO(hkuang): get the StreamTexture transform matrix in GPU process.
   // crbug.com/226218.
   copy_texture_CHROMIUM_->DoCopySubTexture(
       this, source_texture->target(), source_texture->service_id(),
       source_internal_format, dest_texture->service_id(), GL_RGBA,
       xoffset, yoffset, x, y, width, height, dest_width, dest_height,
       source_width, source_height, false, false, false);
+
+  DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 void GLES2DecoderImpl::DoTexStorage2DEXT(
     GLenum target,
     GLint levels,
     GLenum internal_format,
     GLsizei width,
     GLsizei height) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoTexStorage2DEXT",
       "width", width, "height", height);
@@ skipping 392 matching lines @@
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
-  gfx::GLImage* image = image_manager()->LookupImage(image_id);
-  if (!image) {
+  gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
+  if (!gl_image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no image found with the given ID");
     return;
   }
 
-  Texture::ImageState image_state = Texture::UNBOUND;
-
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoBindTexImage2DCHROMIUM", GetErrorState());
-
-    // Note: We fallback to using CopyTexImage() before the texture is used
-    // when BindTexImage() fails.
-    if (image->BindTexImage(target))
-      image_state = Texture::BOUND;
+    if (!gl_image->BindTexImage(target)) {
+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_OPERATION,
+          "glBindTexImage2DCHROMIUM", "fail to bind image with the given ID");
+      return;
+    }
   }
 
-  gfx::Size size = image->GetSize();
-  GLenum internalformat = image->GetInternalFormat();
+  gfx::Size size = gl_image->GetSize();
   texture_manager()->SetLevelInfo(
-      texture_ref, target, 0, internalformat, size.width(), size.height(), 1, 0,
-      internalformat, GL_UNSIGNED_BYTE, gfx::Rect(size));
-  texture_manager()->SetLevelImage(texture_ref, target, 0, image, image_state);
+      texture_ref, target, 0, gl_image->GetInternalFormat(), size.width(),
+      size.height(), 1, 0, gl_image->GetInternalFormat(), GL_UNSIGNED_BYTE,
+      gfx::Rect(size));
+  texture_manager()->SetLevelImage(texture_ref, target, 0, gl_image);
 }
 
 void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
     GLenum target, GLint image_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM");
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
-  gfx::GLImage* image = image_manager()->LookupImage(image_id);
-  if (!image) {
+  gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
+  if (!gl_image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no image found with the given ID");
     return;
   }
 
-  Texture::ImageState image_state;
-
   // Do nothing when image is not currently bound.
-  if (texture_ref->texture()->GetLevelImage(target, 0, &image_state) != image)
+  if (texture_ref->texture()->GetLevelImage(target, 0) != gl_image)
     return;
 
-  if (image_state == Texture::BOUND) {
+  {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM", GetErrorState());
-
-    image->ReleaseTexImage(target);
-    texture_manager()->SetLevelInfo(texture_ref, target, 0, GL_RGBA, 0, 0, 1, 0,
-                                    GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
+    gl_image->ReleaseTexImage(target);
   }
 
-  texture_manager()->SetLevelImage(texture_ref, target, 0, nullptr,
-                                   Texture::UNBOUND);
+  texture_manager()->SetLevelInfo(
+      texture_ref, target, 0, gl_image->GetInternalFormat(), 0, 0, 1, 0,
+      gl_image->GetInternalFormat(), GL_UNSIGNED_BYTE, gfx::Rect());
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::TraceBeginCHROMIUM& c =
       *static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
   Bucket* category_bucket = GetBucket(c.category_bucket_id);
   Bucket* name_bucket = GetBucket(c.name_bucket_id);
   if (!category_bucket || category_bucket->size() == 0 ||
@@ skipping 334 matching lines @@
     // the contexts in the share group.
     LOG(ERROR) << "glUnmapBuffer unexpectedly returned GL_FALSE";
     // Need to lose current context before broadcasting!
     MarkContextLost(error::kGuilty);
     group_->LoseContexts(error::kInnocent);
     return error::kLostContext;
   }
   return error::kNoError;
 }
 
+void GLES2DecoderImpl::OnTextureRefDetachedFromFramebuffer(
+    TextureRef* texture_ref) {
+  Texture* texture = texture_ref->texture();
+  DoDidUseTexImageIfNeeded(texture, texture->target());
+}
+
 // Note that GL_LOST_CONTEXT is specific to GLES.
 // For desktop GL we have to query the reset status proactively.
 void GLES2DecoderImpl::OnContextLostError() {
   if (!WasContextLost()) {
     // Need to lose current context before broadcasting!
     CheckResetStatus();
     group_->LoseContexts(error::kUnknown);
     reset_by_robustness_extension_ = true;
   }
 }
@@ skipping 434 matching lines @@
   return error::kNoError;
 }
 
 // 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