gpu: Refactor to support cross-channel shared textures

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 675 matching lines @@
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
   }
 
   // Creates a Texture for the given texture.
-  Texture* CreateTexture(
+  TextureRef* CreateTexture(
       GLuint client_id, GLuint service_id) {
     return texture_manager()->CreateTexture(client_id, service_id);
   }
 
   // Gets the texture info for the given texture. Returns NULL if none exists.
-  Texture* GetTexture(GLuint client_id) const {
+  TextureRef* GetTexture(GLuint client_id) const {
     return texture_manager()->GetTexture(client_id);
   }
 
   // Deletes the texture info for the given texture.
   void RemoveTexture(GLuint client_id) {
     texture_manager()->RemoveTexture(client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
@@ skipping 653 matching lines @@
   Buffer* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     if (target == GL_ARRAY_BUFFER) {
       return state_.bound_array_buffer;
     } else {
       return state_.vertex_attrib_manager->element_array_buffer();
     }
   }
 
   // Gets the texture id for a given target.
-  Texture* GetTextureInfoForTarget(GLenum target) {
+  TextureRef* GetTextureInfoForTarget(GLenum target) {
     TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
-    Texture* texture = NULL;
+    TextureRef* texture = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
         texture = unit.bound_texture_2d;
         break;
       case GL_TEXTURE_CUBE_MAP:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
         texture = unit.bound_texture_cube_map;
         break;
       case GL_TEXTURE_EXTERNAL_OES:
         texture = unit.bound_texture_external_oes;
         break;
       case GL_TEXTURE_RECTANGLE_ARB:
         texture = unit.bound_texture_rectangle_arb;
         break;
       default:
         NOTREACHED();
         return NULL;
     }
     return texture;
   }
 
-  Texture* GetTextureInfoForTargetUnlessDefault(
+  TextureRef* GetTextureInfoForTargetUnlessDefault(
       GLenum target) {
-    Texture* texture = GetTextureInfoForTarget(target);
+    TextureRef* texture = GetTextureInfoForTarget(target);
     if (!texture)
       return NULL;
     if (texture == texture_manager()->GetDefaultTextureInfo(target))
       return NULL;
     return texture;
   }
 
   GLenum GetBindTargetForSamplerType(GLenum type) {
     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
            type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
@@ skipping 186 matching lines @@
   scoped_ptr<BackRenderbuffer> offscreen_target_stencil_render_buffer_;
   GLenum offscreen_target_color_format_;
   GLenum offscreen_target_depth_format_;
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
   GLboolean offscreen_target_buffer_preserved_;
 
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<BackFramebuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<BackTexture> offscreen_saved_color_texture_;
-  scoped_refptr<Texture>
+  scoped_refptr<TextureRef>
       offscreen_saved_color_texture_info_;
 
   // The copy that is used as the destination for multi-sample resolves.
   scoped_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<QueryManager> query_manager_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
@@ skipping 599 matching lines @@
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
 
   state_.texture_units.resize(group_->max_texture_units());
   for (uint32 tt = 0; tt < state_.texture_units.size(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // We want the last bind to be 2D.
-    Texture* texture;
+    TextureRef* ref;
     if (features().oes_egl_image_external) {
-      texture = texture_manager()->GetDefaultTextureInfo(
+      ref = texture_manager()->GetDefaultTextureInfo(
           GL_TEXTURE_EXTERNAL_OES);
-      state_.texture_units[tt].bound_texture_external_oes = texture;
-      glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture->service_id());
+      state_.texture_units[tt].bound_texture_external_oes = ref;
+      glBindTexture(GL_TEXTURE_EXTERNAL_OES, ref->service_id());
     }
     if (features().arb_texture_rectangle) {
-      texture = texture_manager()->GetDefaultTextureInfo(
+      ref = texture_manager()->GetDefaultTextureInfo(
           GL_TEXTURE_RECTANGLE_ARB);
-      state_.texture_units[tt].bound_texture_rectangle_arb = texture;
-      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture->service_id());
+      state_.texture_units[tt].bound_texture_rectangle_arb = ref;
+      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, ref->service_id());
     }
-    texture = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
-    state_.texture_units[tt].bound_texture_cube_map = texture;
-    glBindTexture(GL_TEXTURE_CUBE_MAP, texture->service_id());
-    texture = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
-    state_.texture_units[tt].bound_texture_2d = texture;
-    glBindTexture(GL_TEXTURE_2D, texture->service_id());
+    ref = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
+    state_.texture_units[tt].bound_texture_cube_map = ref;
+    glBindTexture(GL_TEXTURE_CUBE_MAP, ref->service_id());
+    ref = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
+    state_.texture_units[tt].bound_texture_2d = ref;
+    glBindTexture(GL_TEXTURE_2D, ref->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
   ContextCreationAttribParser attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
 
   // These are NOT if the back buffer has these proprorties. They are
   // if we want the command buffer to enforce them regardless of what
@@ skipping 432 matching lines @@
       RemoveRenderbuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
-    Texture* texture = GetTexture(client_ids[ii]);
-    if (texture && !texture->IsDeleted()) {
+    TextureRef* texture_ref = GetTexture(client_ids[ii]);
+    if (texture_ref) {
+      Texture* texture = texture_ref->texture();
       if (texture->IsAttachedToFramebuffer()) {
         clear_state_dirty_ = true;
       }
-      // Unbind texture from texture units.
+      // Unbind texture_ref from texture_ref units.
       for (size_t jj = 0; jj < state_.texture_units.size(); ++jj) {
-        state_.texture_units[jj].Unbind(texture);
+        state_.texture_units[jj].Unbind(texture_ref);
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
         if (state_.bound_read_framebuffer) {
           state_.bound_read_framebuffer->UnbindTexture(
-              GL_READ_FRAMEBUFFER_EXT, texture);
+              GL_READ_FRAMEBUFFER_EXT, texture_ref);
         }
         if (state_.bound_draw_framebuffer) {
           state_.bound_draw_framebuffer->UnbindTexture(
-              GL_DRAW_FRAMEBUFFER_EXT, texture);
+              GL_DRAW_FRAMEBUFFER_EXT, texture_ref);
         }
       } else {
         if (state_.bound_draw_framebuffer) {
-          state_.bound_draw_framebuffer->UnbindTexture(GL_FRAMEBUFFER, texture);
+          state_.bound_draw_framebuffer->UnbindTexture(GL_FRAMEBUFFER,
+                                                       texture_ref);
         }
       }
       GLuint service_id = texture->service_id();
       if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
 #if defined(OS_MACOSX)
       if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
         ReleaseIOSurfaceForTexture(service_id);
       }
@@ skipping 24 matching lines @@
   }
 
   ProcessFinishedAsyncTransfers();
   if (workarounds().flush_on_context_switch)
     glFlush();
 
   // Rebind the FBO if it was unbound by the context.
   if (workarounds().unbind_fbo_on_context_switch)
     RestoreFramebufferBindings();
 
+  clear_state_dirty_ = true;

[piman, 2013/05/14 01:34:50]

Note on this because it may be non-obvious.

My understanding of the meaning of clear_state_dirty_ is that when we change a
FBO attachment, we may need to change things like color mask (assuming because
we don't trust the driver to do it?). clear_state_dirty_ is set to indicate that
we need to reset that state before drawing (and is cleared in
DoDrawArrays/Elements via ApplyDirtyState).
Current code does it for the current context whenever we change a texture that
may be bound to a FBO. However it should in theory also affect other contexts
that may also have this texture bound to a FBO, but I can't find code that does
it.

This would do the trick in that we assume that if we switch context then we need
to revalidate the current FBO state since it may have changed in another
context.


Note - I may be completely missing the mark here in which case please let me
know.

[greggman, 2013/05/15 21:11:38]

clear_state_dirty_ means the a bunch of state related to clearing has been
munged and needs to be restored before clearing/drawing.  Looking at the code
now it's possible it's being set to true in places that it no longer needs to be
set to true.

I honestly don't remember why it's being set after changing a texture attached
to an fbo :-( 

+
   return true;
 }
 
 void GLES2DecoderImpl::ProcessFinishedAsyncTransfers() {
   if (engine() && query_manager_.get())
     query_manager_->ProcessPendingTransferQueries();
 
   // TODO(epenner): Is there a better place to do this?
   // This needs to occur before we execute any batch of commands
   // from the client, as the client may have recieved an async
@@ skipping 181 matching lines @@
   } else {
     return back_buffer_color_format_;
   }
 }
 
 void GLES2DecoderImpl::UpdateParentTextureInfo() {
   if (parent_) {
     // Update the info about the offscreen saved color texture in the parent.
     // The reference to the parent is a weak pointer and will become null if the
     // parent is later destroyed.
+    GLenum target = offscreen_saved_color_texture_info_->texture()->target();
     TextureManager* parent_texture_manager = parent_->texture_manager();
-    glBindTexture(offscreen_saved_color_texture_info_->target(),
-                  offscreen_saved_color_texture_info_->service_id());
+    glBindTexture(target, offscreen_saved_color_texture_info_->service_id());
     parent_texture_manager->SetLevelInfo(
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_2D,
         0,  // level
         GL_RGBA,
         offscreen_size_.width(),
         offscreen_size_.height(),
         1,  // depth
         0,  // border
         GL_RGBA,
@@ skipping 16 matching lines @@
         GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_S,
         GL_CLAMP_TO_EDGE);
     parent_texture_manager->SetParameter(
         "UpdateParentTextureInfo",
         GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
-    Texture* texture = GetTextureInfoForTarget(
-        offscreen_saved_color_texture_info_->target());
-    glBindTexture(texture->target(), texture->service_id());
+    TextureRef* texture_ref = GetTextureInfoForTarget(target);
+    glBindTexture(target, texture_ref->service_id());
   } else {
     offscreen_saved_color_texture_info_ = NULL;
   }
 }
 
 void GLES2DecoderImpl::SetResizeCallback(
     const base::Callback<void(gfx::Size)>& callback) {
   resize_callback_ = callback;
 }
 
@@ skipping 24 matching lines @@
   return async_pixel_transfer_delegate_.get();
 }
 
 void GLES2DecoderImpl::SetAsyncPixelTransferDelegate(
     AsyncPixelTransferDelegate* delegate) {
   async_pixel_transfer_delegate_ = make_scoped_ptr(delegate);
 }
 
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
-  Texture* texture = texture_manager()->GetTexture(client_texture_id);
-  if (texture) {
-    *service_texture_id = texture->service_id();
+  TextureRef* texture_ref = texture_manager()->GetTexture(client_texture_id);
+  if (texture_ref) {
+    *service_texture_id = texture_ref->service_id();
     return true;
   }
   return false;
 }
 
 uint32 GLES2DecoderImpl::GetTextureUploadCount() {
   return texture_upload_count_ +
       async_pixel_transfer_delegate_->GetTextureUploadCount();
 }
 
@@ skipping 178 matching lines @@
     GLuint service_id = offscreen_saved_color_texture_->id();
 
     // Replace texture info when ID is already in use by parent.
     if (new_parent_impl->texture_manager()->GetTexture(
         new_parent_texture_id))
       new_parent_impl->texture_manager()->RemoveTexture(
           new_parent_texture_id);
 
     offscreen_saved_color_texture_info_ =
         new_parent_impl->CreateTexture(new_parent_texture_id, service_id);
-    offscreen_saved_color_texture_info_->SetNotOwned();
+    offscreen_saved_color_texture_info_->texture()->SetNotOwned();
     new_parent_impl->texture_manager()->
        SetTarget(offscreen_saved_color_texture_info_, GL_TEXTURE_2D);
 
     parent_ = base::AsWeakPtr<GLES2DecoderImpl>(new_parent_impl);
 
     UpdateParentTextureInfo();
   } else {
     parent_.reset();
     offscreen_saved_color_texture_info_ = NULL;
   }
@@ skipping 418 matching lines @@
         state_.bound_read_framebuffer->service_id() :
         GetBackbufferServiceId();
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER, service_id);
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::RestoreTextureState(unsigned service_id) const {
   GLuint client_id = 0;
   if (texture_manager()->GetClientId(service_id, &client_id)) {
-    Texture* texture = GetTexture(client_id);
+    Texture* texture = GetTexture(client_id)->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());
@@ skipping 92 matching lines @@
       service_id = renderbuffer->service_id();
     }
     renderbuffer->MarkAsValid();
   }
   LogClientServiceForInfo(renderbuffer, client_id, "glBindRenerbuffer");
   state_.bound_renderbuffer = renderbuffer;
   glBindRenderbufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
-  Texture* texture = NULL;
+  TextureRef* texture_ref = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    texture = GetTexture(client_id);
-    if (!texture) {
+    texture_ref = GetTexture(client_id);
+    if (!texture_ref) {
       if (!group_->bind_generates_resource()) {
          LOG(ERROR) << "glBindTexture: id not generated by glGenTextures";
          current_decoder_error_ = error::kGenericError;
          return;
       }
 
       // It's a new id so make a texture texture for it.
       glGenTextures(1, &service_id);
       DCHECK_NE(0u, service_id);
       CreateTexture(client_id, service_id);
-      texture = GetTexture(client_id);
+      texture_ref = GetTexture(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kTextures);
       id_allocator->MarkAsUsed(client_id);
     }
   } else {
-    texture = texture_manager()->GetDefaultTextureInfo(target);
+    texture_ref = texture_manager()->GetDefaultTextureInfo(target);
   }
+  Texture* texture = texture_ref->texture();
 
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
   if (texture->target() != 0 && texture->target() != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
   if (texture->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexture", "illegal target for stream texture.");
     return;
   }
   LogClientServiceForInfo(texture, client_id, "glBindTexture");
   if (texture->target() == 0) {
-    texture_manager()->SetTarget(texture, target);
+    texture_manager()->SetTarget(texture_ref, target);
   }
   glBindTexture(target, texture->service_id());
 
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
-      unit.bound_texture_2d = texture;
+      unit.bound_texture_2d = texture_ref;
       break;
     case GL_TEXTURE_CUBE_MAP:
-      unit.bound_texture_cube_map = texture;
+      unit.bound_texture_cube_map = texture_ref;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
-      unit.bound_texture_external_oes = texture;
+      unit.bound_texture_external_oes = texture_ref;
       if (texture->IsStreamTexture()) {
         DCHECK(stream_texture_manager_);
         StreamTexture* stream_tex =
             stream_texture_manager_->LookupStreamTexture(texture->service_id());
         if (stream_tex)
           stream_tex->Update();
       }
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
-      unit.bound_texture_rectangle_arb = texture;
+      unit.bound_texture_rectangle_arb = texture_ref;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, false)) {
     if (index != 0 ||
@@ skipping 56 matching lines @@
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glEnableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture ||
-      !texture_manager()->CanGenerateMipmaps(texture)) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref ||
+      !texture_manager()->CanGenerateMipmaps(texture_ref)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glGenerateMipmap", "Can not generate mips");
     return;
   }
 
   if (target == GL_TEXTURE_CUBE_MAP) {
     for (int i = 0; i < 6; ++i) {
       GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
-      if (!texture_manager()->ClearTextureLevel(this, texture, face, 0)) {
+      if (!texture_manager()->ClearTextureLevel(this, texture_ref, face, 0)) {
         LOCAL_SET_GL_ERROR(
             GL_OUT_OF_MEMORY, "glGenerateMipmap", "dimensions too big");
         return;
       }
     }
   } else {
-    if (!texture_manager()->ClearTextureLevel(this, texture, target, 0)) {
+    if (!texture_manager()->ClearTextureLevel(this, texture_ref, target, 0)) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, "glGenerateMipmap", "dimensions too big");
       return;
     }
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glGenerateMipmap");
   // Workaround for Mac driver bug. In the large scheme of things setting
   // glTexParamter twice for glGenerateMipmap is probably not a lage performance
   // hit so there's probably no need to make this conditional. The bug appears
   // to be that if the filtering mode is set to something that doesn't require
   // mipmaps for rendering, or is never set to something other than the default,
   // then glGenerateMipmap misbehaves.
   if (workarounds().set_texture_filter_before_generating_mipmap) {
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
   }
   glGenerateMipmapEXT(target);
   if (workarounds().set_texture_filter_before_generating_mipmap) {
-    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, texture->min_filter());
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
+                    texture_ref->texture()->min_filter());
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glGenerateMipmap");
   if (error == GL_NO_ERROR) {
-    texture_manager()->MarkMipmapsGenerated(texture);
+    texture_manager()->MarkMipmapsGenerated(texture_ref);
   }
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (pname) {
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
         *num_written = 1;
@@ skipping 868 matching lines @@
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glFramebufferTexture2D", "no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
-  Texture* texture = NULL;
+  TextureRef* texture_ref = NULL;
   if (client_texture_id) {
-    texture = GetTexture(client_texture_id);
-    if (!texture) {
+    texture_ref = GetTexture(client_texture_id);
+    if (!texture_ref) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
-          "glFramebufferTexture2D", "unknown texture");
+          "glFramebufferTexture2D", "unknown texture_ref");
       return;
     }
-    service_id = texture->service_id();
+    service_id = texture_ref->service_id();
   }
 
   if (!texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glFramebufferTexture2D", "level out of range");
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferTexture2D");
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferTexture2D");
   if (error == GL_NO_ERROR) {
-    framebuffer->AttachTexture(attachment, texture, textarget, level);
+    framebuffer->AttachTexture(attachment, texture_ref, textarget, level);
   }
   if (framebuffer == state_.bound_draw_framebuffer) {
     clear_state_dirty_ = true;
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
@@ skipping 220 matching lines @@
       if (workarounds().use_current_program_after_successful_link) {
         glUseProgram(program->service_id());
       }
       program_manager()->ClearUniforms(program);
     }
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
       "glTexParameterf", GetErrorState(), texture, pname,
       static_cast<GLint>(param));
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
       "glTexParameteri", GetErrorState(), texture, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterfv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
       "glTexParameterfv", GetErrorState(), texture, pname,
       static_cast<GLint>(params[0]));
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
       "glTexParameteriv", GetErrorState(), texture, pname, *params);
 }
 
@@ skipping 443 matching lines @@
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-        Texture* texture =
+        TextureRef* texture =
             texture_unit.GetInfoForSamplerType(uniform_info->type);
         if (!texture || !texture_manager()->CanRender(texture)) {
           textures_set = true;
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           glBindTexture(
               GetBindTargetForSamplerType(uniform_info->type),
               texture_manager()->black_texture_id(uniform_info->type));
           LOCAL_RENDER_WARNING(
               std::string("texture bound to texture unit ") +
               base::IntToString(texture_unit_index) +
@@ skipping 13 matching lines @@
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-        Texture* texture = uniform_info->type == GL_SAMPLER_2D ?
+        TextureRef* texture_ref = uniform_info->type == GL_SAMPLER_2D ?
             texture_unit.bound_texture_2d :
             texture_unit.bound_texture_cube_map;
-        if (!texture || !texture_manager()->CanRender(texture)) {
+        if (!texture_ref || !texture_manager()->CanRender(texture_ref)) {
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
-          // Get the texture info that was previously bound here.
-          texture = texture_unit.bind_target == GL_TEXTURE_2D ?
+          // Get the texture_ref info that was previously bound here.
+          texture_ref = texture_unit.bind_target == GL_TEXTURE_2D ?
               texture_unit.bound_texture_2d :
               texture_unit.bound_texture_cube_map;
           glBindTexture(texture_unit.bind_target,
-                        texture ? texture->service_id() : 0);
+                        texture_ref ? texture_ref->service_id() : 0);
         }
       }
     }
   }
   // 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()) {
     return true;
   }
 
   // 1: Check all textures we are about to render with.
   if (state_.current_program) {
     const Program::SamplerIndices& sampler_indices =
        state_.current_program->sampler_indices();
     for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
       const Program::UniformInfo* uniform_info =
           state_.current_program->GetUniformInfo(sampler_indices[ii]);
       DCHECK(uniform_info);
       for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
         GLuint texture_unit_index = uniform_info->texture_units[jj];
         if (texture_unit_index < state_.texture_units.size()) {
           TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-          Texture* texture =
+          TextureRef* texture_ref =
               texture_unit.GetInfoForSamplerType(uniform_info->type);
-          if (texture && !texture->SafeToRenderFrom()) {
-            if (!texture_manager()->ClearRenderableLevels(this, texture)) {
+          if (texture_ref && !texture_ref->texture()->SafeToRenderFrom()) {
+            if (!texture_manager()->ClearRenderableLevels(this, texture_ref)) {
               return false;
             }
           }
         }
       }
     }
   }
   return true;
 }
 
@@ skipping 675 matching lines @@
 }
 
 bool GLES2DecoderImpl::DoIsShader(GLuint client_id) {
   // IsShader is true for shaders as soon as they are created, until they
   // are deleted and not attached to any programs.
   const Shader* shader = GetShader(client_id);
   return shader != NULL && !shader->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsTexture(GLuint client_id) {
-  const Texture* texture = GetTexture(client_id);
-  return texture && texture->IsValid() && !texture->IsDeleted();
+  const TextureRef* texture_ref = GetTexture(client_id);
+  return texture_ref && texture_ref->texture()->IsValid();
 }
 
 void GLES2DecoderImpl::DoAttachShader(
     GLuint program_client_id, GLint shader_client_id) {
   Program* program = GetProgramInfoNotShader(
       program_client_id, "glAttachShader");
   if (!program) {
     return;
   }
   Shader* shader = GetShaderInfoNotProgram(shader_client_id, "glAttachShader");
@@ skipping 896 matching lines @@
   while (y < height) {
     GLint h = y + tile_height > height ? height - y : tile_height;
     if (is_texture_immutable || h != height) {
       glTexSubImage2D(target, level, 0, y, width, h, format, type, zero.get());
     } else {
       glTexImage2D(
           target, level, format, width, h, 0, format, type, zero.get());
     }
     y += tile_height;
   }
-  Texture* texture = GetTextureInfoForTarget(bind_target);
+  TextureRef* texture = GetTextureInfoForTarget(bind_target);
   glBindTexture(bind_target, texture ? texture->service_id() : 0);
   return true;
 }
 
 namespace {
 
 const int kS3TCBlockWidth = 4;
 const int kS3TCBlockHeight = 4;
 const int kS3TCDXT1BlockSize = 8;
 const int kS3TCDXT3AndDXT5BlockSize = 16;
@@ skipping 154 matching lines @@
         "glCompressedTexImage2D", internal_format, "internal_format");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCompressedTexImage2D", "dimensions out of range");
     return error::kNoError;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCompressedTexImage2D", "unknown texture target");
     return error::kNoError;
   }
+  Texture* texture = texture_ref->texture();
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCompressedTexImage2D", "texture is immutable");
     return error::kNoError;
   }
 
   if (!ValidateCompressedTexDimensions(
       "glCompressedTexImage2D", level, width, height, internal_format) ||
       !ValidateCompressedTexFuncData(
       "glCompressedTexImage2D", width, height, internal_format, image_size)) {
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
-    // TODO(gman): If textures tracked which framebuffers they were attached to
-    // we could just mark those framebuffers as not complete.
-    framebuffer_manager()->IncFramebufferStateChangeCount();

[piman, 2013/05/14 01:34:50]

Note: this is done from SetLevelInfo now.

   }
 
   scoped_ptr<int8[]> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
-        texture, target, level, internal_format, width, height, 1, border, 0, 0,
-        true);
+        texture_ref, target, level, internal_format,
+        width, height, 1, border, 0, 0, true);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
     uint32 immediate_data_size, const cmds::CompressedTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
@@ skipping 172 matching lines @@
         GL_INVALID_VALUE, function_name, "dimensions out of range");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && pixels) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         function_name, "can not supply data for depth or stencil textures");
     return false;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "unknown texture for target");
     return false;
   }
-  if (texture->IsImmutable()) {
+  if (texture_ref->texture()->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "texture is immutable");
     return false;
   }
   return true;
 }
 
 void GLES2DecoderImpl::DoTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels,
     uint32 pixels_size) {
   if (!ValidateTexImage2D("glTexImage2D", target, level, internal_format,
       width, height, border, format, type, pixels, pixels_size)) {
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(pixels_size)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
     return;
   }
 
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  Texture* texture = texture_ref->texture();
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   GLenum tex_type = 0;
   GLenum tex_format = 0;
   bool level_is_same =
       texture->GetLevelSize(target, level, &tex_width, &tex_height) &&
       texture->GetLevelType(target, level, &tex_type, &tex_format) &&
       width == tex_width && height == tex_height &&
       type == tex_type && format == tex_format;
 
   if (level_is_same && !pixels) {
     // Just set the level texture but mark the texture as uncleared.
     texture_manager()->SetLevelInfo(
-        texture,
+        texture_ref,
         target, level, internal_format, width, height, 1, border, format, type,
         false);
     tex_image_2d_failed_ = false;
     return;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
-    // TODO(gman): If textures tracked which framebuffers they were attached to
-    // we could just mark those framebuffers as not complete.
-    framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   if (!teximage2d_faster_than_texsubimage2d_ && level_is_same && pixels) {
     glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
-    texture_manager()->SetLevelCleared(texture, target, level, true);
+    texture_manager()->SetLevelCleared(texture_ref, target, level, true);
     tex_image_2d_failed_ = false;
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glTexImage2D");
   glTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   GLenum error = LOCAL_PEEK_GL_ERROR("glTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
-        texture,
+        texture_ref,
         target, level, internal_format, width, height, 1, border, format, type,
         pixels != NULL);
     tex_image_2d_failed_ = false;
   }
   return;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(
     uint32 immediate_data_size, const cmds::TexImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexImage2D");
@@ skipping 59 matching lines @@
 void GLES2DecoderImpl::DoCompressedTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
   GLsizei image_size,
   const void * data) {
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCompressedTexSubImage2D", "unknown texture for target");
     return;
   }
+  Texture* texture = texture_ref->texture();
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &type, &internal_format)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCompressedTexSubImage2D", "level does not exist.");
     return;
   }
   if (internal_format != format) {
     LOCAL_SET_GL_ERROR(
@@ skipping 45 matching lines @@
 void GLES2DecoderImpl::DoCopyTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
   DCHECK(!ShouldDeferReads());
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCopyTexImage2D", "unknown texture for target");
     return;
   }
+  Texture* texture = texture_ref->texture();
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glCopyTexImage2D", "texture is immutable");
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
     return;
   }
@@ skipping 37 matching lines @@
   if (!CheckBoundFramebuffersValid("glCopyTexImage2D")) {
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyTexImage2D");
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
   if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
-    // TODO(gman): If textures tracked which framebuffers they were attached to
-    // we could just mark those framebuffers as not complete.
-    framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   // Clip to size to source dimensions
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
@@ skipping 19 matching lines @@
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
     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, target, level, internal_format, width, height, 1,
+        texture_ref, target, level, internal_format, width, height, 1,
         border, internal_format, GL_UNSIGNED_BYTE, true);
   }
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
   DCHECK(!ShouldDeferReads());
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCopyTexSubImage2D", "unknown texture for target");
     return;
   }
+  Texture* texture = texture_ref->texture();
   GLenum type = 0;
   GLenum format = 0;
   if (!texture->GetLevelType(target, level, &type, &format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
   if (texture->AsyncTransferIsInProgress()) {
@@ skipping 28 matching lines @@
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
-  if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
+  if (!texture_manager()->ClearTextureLevel(this, texture_ref, target, level)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCopyTexSubImage2D", "dimensions too big");
     return;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
@@ skipping 49 matching lines @@
     return false;
   }
   if (!validators_->texture_format.IsValid(format)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, format, "format");
     return false;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, type, "type");
     return false;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         function_name, "unknown texture for target");
     return false;
   }
+  Texture* texture = texture_ref->texture();
   GLenum current_type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &current_type, &internal_format)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "level does not exist.");
     return false;
   }
   if (format != internal_format) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ skipping 39 matching lines @@
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     const void * data) {
   error::Error error = error::kNoError;
   if (!ValidateTexSubImage2D(&error, "glTexSubImage2D", target, level,
       xoffset, yoffset, width, height, format, type, data)) {
     return error;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  Texture* texture = texture_ref->texture();
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   bool ok = texture->GetLevelSize(target, level, &tex_width, &tex_height);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 ||
       width != tex_width || height != tex_height) {
-    if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
+    if (!texture_manager()->ClearTextureLevel(this, texture_ref,
+                                              target, level)) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
       return error::kNoError;
     }
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
     return error::kNoError;
   }
 
   if (teximage2d_faster_than_texsubimage2d_ && !texture->IsImmutable()) {
     ScopedTextureUploadTimer timer(this);
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
     glTexImage2D(
         target, level, format, width, height, 0, format, type, data);
   } else {
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
-  texture_manager()->SetLevelCleared(texture, target, level, true);
+  texture_manager()->SetLevelCleared(texture_ref, target, level, true);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32 immediate_data_size, const cmds::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
@@ skipping 439 matching lines @@
                                      offscreen_target_frame_buffer_->id());
 
       if (offscreen_target_buffer_preserved_) {
         // Copy the target frame buffer to the saved offscreen texture.
         offscreen_saved_color_texture_->Copy(
             offscreen_saved_color_texture_->size(),
             offscreen_saved_color_format_);
       } else {
         // Flip the textures in the parent context via the texture manager.
         if (!!offscreen_saved_color_texture_info_.get())
-          offscreen_saved_color_texture_info_->
+          offscreen_saved_color_texture_info_->texture()->
               SetServiceId(offscreen_target_color_texture_->id());
 
         offscreen_saved_color_texture_.swap(offscreen_target_color_texture_);
         offscreen_target_frame_buffer_->AttachRenderTexture(
             offscreen_target_color_texture_.get());
       }
 
       // Ensure the side effects of the copy are visible to the parent
       // context. There is no need to do this for ANGLE because it uses a
       // single D3D device for all contexts.
@@ skipping 539 matching lines @@
   }
 
   uint32 client_id = c.client_id;
   typedef cmds::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
 
   if (!result)
     return error::kOutOfBounds;
   *result = GL_ZERO;
-  Texture* texture = texture_manager()->GetTexture(client_id);
-  if (!texture) {
+  TextureRef* texture_ref = texture_manager()->GetTexture(client_id);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCreateStreamTextureCHROMIUM", "bad texture id.");
     return error::kNoError;
   }
 
+  Texture* texture = texture_ref->texture();
   if (texture->IsStreamTexture()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCreateStreamTextureCHROMIUM", "is already a stream texture.");
     return error::kNoError;
   }
 
   if (texture->target() && texture->target() != GL_TEXTURE_EXTERNAL_OES) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ skipping 17 matching lines @@
   }
 
   *result = object_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const cmds::DestroyStreamTextureCHROMIUM& c) {
   GLuint client_id = c.texture;
-  Texture* texture = texture_manager()->GetTexture(client_id);
-  if (texture && texture->IsStreamTexture()) {
+  TextureRef* texture_ref = texture_manager()->GetTexture(client_id);
+  if (texture_ref && texture_ref->texture()->IsStreamTexture()) {
     if (!stream_texture_manager_)
       return error::kInvalidArguments;
 
-    stream_texture_manager_->DestroyStreamTexture(texture->service_id());
-    texture->SetStreamTexture(false);
+    stream_texture_manager_->DestroyStreamTexture(texture_ref->service_id());
+    texture_ref->texture()->SetStreamTexture(false);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
 
   return error::kNoError;
 }
 
 #if defined(OS_MACOSX)
@@ skipping 35 matching lines @@
     // know what's going on.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM",
         "requires TEXTURE_RECTANGLE_ARB target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "no rectangle texture bound");
     return;
   }
 
   // Look up the new IOSurface. Note that because of asynchrony
   // between processes this might fail; during live resizing the
   // plugin process might allocate and release an IOSurface before
   // this process gets a chance to look it up. Hold on to any old
   // IOSurface in this case.
   CFTypeRef surface = surface_support->IOSurfaceLookup(io_surface_id);
   if (!surface) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "no IOSurface with the given ID");
     return;
   }
 
   // Release any IOSurface previously bound to this texture.
-  ReleaseIOSurfaceForTexture(texture->service_id());
+  ReleaseIOSurfaceForTexture(texture_ref->service_id());
 
   // Make sure we release the IOSurface even if CGLTexImageIOSurface2D fails.
   texture_to_io_surface_map_.insert(
-      std::make_pair(texture->service_id(), surface));
+      std::make_pair(texture_ref->service_id(), surface));
 
   CGLContextObj context =
       static_cast<CGLContextObj>(context_->GetHandle());
 
   CGLError err = surface_support->CGLTexImageIOSurface2D(
       context,
       target,
       GL_RGBA,
       width,
       height,
       GL_BGRA,
       GL_UNSIGNED_INT_8_8_8_8_REV,
       surface,
       plane);
 
   if (err != kCGLNoError) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "error in CGLTexImageIOSurface2D");
     return;
   }
 
   texture_manager()->SetLevelInfo(
-      texture, target, 0, GL_RGBA, width, height, 1, 0,
+      texture_ref, target, 0, GL_RGBA, width, height, 1, 0,
       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, true);
 
 #else
   LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
              "glTexImageIOSurface2DCHROMIUM", "not supported.");
 #endif
 }
 
 static GLenum ExtractFormatFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
@@ skipping 36 matching lines @@
     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,
     GLenum internal_format, GLenum dest_type) {
-  Texture* dest_texture = GetTexture(dest_id);
-  Texture* source_texture = GetTexture(source_id);
+  TextureRef* dest_texture_ref = GetTexture(dest_id);
+  TextureRef* source_texture_ref = GetTexture(source_id);
 
-  if (!source_texture || !dest_texture) {
+  if (!source_texture_ref || !dest_texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "unknown texture id");
     return;
   }
 
   if (GL_TEXTURE_2D != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "invalid texture target");
     return;
   }
 
+  Texture* source_texture = source_texture_ref->texture();
+  Texture* dest_texture = dest_texture_ref->texture();
   if (dest_texture->target() != GL_TEXTURE_2D ||
       (source_texture->target() != GL_TEXTURE_2D &&
       source_texture->target() != GL_TEXTURE_EXTERNAL_OES)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glCopyTextureCHROMIUM", "invalid texture target binding");
     return;
   }
 
   int source_width, source_height, dest_width, dest_height;
@@ skipping 73 matching lines @@
     glTexImage2D(
         GL_TEXTURE_2D, level, internal_format, source_width, source_height,
         0, internal_format, dest_type, NULL);
     GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTextureCHROMIUM");
     if (error != GL_NO_ERROR) {
       RestoreCurrentTexture2DBindings();
       return;
     }
 
     texture_manager()->SetLevelInfo(
-        dest_texture, GL_TEXTURE_2D, level, internal_format, source_width,
+        dest_texture_ref, GL_TEXTURE_2D, level, internal_format, source_width,
         source_height, 1, 0, internal_format, dest_type, true);
   } else {
     texture_manager()->SetLevelCleared(
-        dest_texture, GL_TEXTURE_2D, level, true);
+        dest_texture_ref, GL_TEXTURE_2D, level, true);
   }
 
   // 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 default matrix crbug.com/226218.
     const static GLfloat default_matrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
                                                0.0f, 1.0f, 0.0f, 0.0f,
                                                0.0f, 0.0f, 1.0f, 0.0f,
@@ skipping 74 matching lines @@
     GLenum internal_format,
     GLsizei width,
     GLsizei height) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoTexStorage2DEXT");
   if (!texture_manager()->ValidForTarget(target, 0, width, height, 1) ||
       TextureManager::ComputeMipMapCount(width, height, 1) < levels) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glTexStorage2DEXT", "dimensions out of range");
     return;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexStorage2DEXT", "unknown texture for target");
     return;
   }
+  Texture* texture = texture_ref->texture();
   if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
   }
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTexStorage2DEXT", "texture is immutable");
     return;
   }
 
@@ skipping 25 matching lines @@
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glTexStorage2DEXT");
   glTexStorage2DEXT(target, levels, internal_format, width, height);
   GLenum error = LOCAL_PEEK_GL_ERROR("glTexStorage2DEXT");
   if (error == GL_NO_ERROR) {
     GLsizei level_width = width;
     GLsizei level_height = height;
     for (int ii = 0; ii < levels; ++ii) {
       texture_manager()->SetLevelInfo(
-          texture, target, ii, format, level_width, level_height, 1, 0, format,
-          type, false);
+          texture_ref, target, ii, format,
+          level_width, level_height, 1, 0, format, type, false);
       level_width = std::max(1, level_width >> 1);
       level_height = std::max(1, level_height >> 1);
     }
     texture->SetImmutable(true);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
     uint32 immediate_data_size, const cmds::GenMailboxCHROMIUM& c) {
   MailboxName name;
   mailbox_manager()->GenerateMailboxName(&name);
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
 
   bucket->SetSize(GL_MAILBOX_SIZE_CHROMIUM);
   bucket->SetData(&name, 0, GL_MAILBOX_SIZE_CHROMIUM);
 
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoProduceTextureCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(mailbox[0]));
 
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glProduceTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
-  TextureDefinition* definition = texture_manager()->Save(texture);
+  TextureDefinition* definition = texture_manager()->Save(texture_ref);
   if (!definition) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glProduceTextureCHROMIUM", "invalid texture");
     return;
   }
 
   if (!group_->mailbox_manager()->ProduceTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox),
       definition,
       texture_manager())) {
     bool success = texture_manager()->Restore(
-        "glProductTextureCHROMIUM", this, texture, definition);
+        "glProductTextureCHROMIUM", this, texture_ref, definition);
     DCHECK(success);
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glProduceTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
-  glBindTexture(texture->target(), texture->service_id());
+  glBindTexture(texture_ref->texture()->target(), texture_ref->service_id());
 }
 
 void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoConsumeTextureCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(mailbox[0]));
 
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glConsumeTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   scoped_ptr<TextureDefinition> definition(
       group_->mailbox_manager()->ConsumeTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox)));
   if (!definition.get()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glConsumeTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
   if (!texture_manager()->Restore(
-      "glConsumeTextureCHROMIUM", this, texture, definition.release())) {
+      "glConsumeTextureCHROMIUM", this, texture_ref, definition.release())) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glConsumeTextureCHROMIUM", "invalid texture");
     return;
   }
 }
 
 void GLES2DecoderImpl::DoInsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   if (!marker) {
@@ skipping 22 matching lines @@
   if (target != GL_TEXTURE_2D) {
     // This might be supported in the future.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "requires TEXTURE_2D target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   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;
   }
 
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoBindTexImage2DCHROMIUM", this);
     if (!gl_image->BindTexImage()) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glBindTexImage2DCHROMIUM", "fail to bind image with the given ID");
       return;
     }
   }
 
   gfx::Size size = gl_image->GetSize();
   texture_manager()->SetLevelInfo(
-      texture, target, 0, GL_RGBA, size.width(), size.height(), 1, 0,
+      texture_ref, target, 0, GL_RGBA, size.width(), size.height(), 1, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, true);
-  texture_manager()->SetLevelImage(texture, target, 0, gl_image);
+  texture_manager()->SetLevelImage(texture_ref, target, 0, gl_image);
 }
 
 void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
     GLenum target, GLint image_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM");
   if (target != GL_TEXTURE_2D) {
     // This might be supported in the future.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "requires TEXTURE_2D target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   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;
   }
 
   // Do nothing when image is not currently bound.
-  if (texture->GetLevelImage(target, 0) != gl_image)
+  if (texture_ref->texture()->GetLevelImage(target, 0) != gl_image)
     return;
 
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM", this);
     gl_image->ReleaseTexImage();
   }
 
   texture_manager()->SetLevelInfo(
-      texture, target, 0, GL_RGBA, 0, 0, 1, 0,
+      texture_ref, target, 0, GL_RGBA, 0, 0, 1, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, false);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     uint32 immediate_data_size, const cmds::TraceBeginCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string command_name;
@@ skipping 126 matching lines @@
   }
 
   // All the normal glTexSubImage2D validation.
   if (!ValidateTexImage2D(
       "glAsyncTexImage2DCHROMIUM", target, level, internal_format,
       width, height, border, format, type, pixels, pixels_size)) {
     return error::kNoError;
   }
 
   // Extra async validation.
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  Texture* texture = texture_ref->texture();
   if (!ValidateAsyncTransfer(
       "glAsyncTexImage2DCHROMIUM", texture, target, level, pixels))
     return error::kNoError;
 
   // Don't allow async redefinition of a textures.
   if (texture->IsDefined()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glAsyncTexImage2DCHROMIUM", "already defined");
     return error::kNoError;
   }
 
-  // Since we don't allow async redefinition, this is the only
-  // time the size of this texture can change while bound
-  // as a frame-buffer.
-  if (texture->IsAttachedToFramebuffer()) {
-    // TODO(gman): If textures tracked which framebuffers they were attached to
-    // we could just mark those framebuffers as not complete.
-    framebuffer_manager()->IncFramebufferStateChangeCount();
-  }
-
   if (!EnsureGPUMemoryAvailable(pixels_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glAsyncTexImage2DCHROMIUM", "out of memory");
     return error::kNoError;
   }
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.pixels_shm_offset;
   uint32 shm_data_size = pixels_size;
 
   // Setup the parameters.
   AsyncTexImage2DParams tex_params = {
       target, level, static_cast<GLenum>(internal_format),
       width, height, border, format, type};
   AsyncMemoryParams mem_params = {
       shared_memory, shm_size, shm_data_offset, shm_data_size};
 
   // Set up the async state if needed, and make the texture
   // immutable so the async state stays valid. The level info
   // is set up lazily when the transfer completes.
   DCHECK(!texture->GetAsyncTransferState());
-  texture->SetAsyncTransferState(
+  texture_ref->SetAsyncTransferState(
       make_scoped_ptr(
           async_pixel_transfer_delegate_->CreatePixelTransferState(
               texture->service_id(),
               tex_params)));
   texture->SetImmutable(true);
 
   async_pixel_transfer_delegate_->AsyncTexImage2D(
       texture->GetAsyncTransferState(),
       tex_params,
       mem_params,
       base::Bind(&TextureManager::SetLevelInfoFromParams,
-                 // The callback is only invoked if the transfer state
-                 // still exists, which implies through manager->info->state
+                 // The callback is only invoked if the transfer delegate still
+                 // exists, which implies through manager->texture_ref->state
                  // ownership that both of these pointers are valid.
                  base::Unretained(texture_manager()),
-                 base::Unretained(texture),
+                 base::Unretained(texture_ref),
                  tex_params));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
     uint32 immediate_data_size, const cmds::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
@@ skipping 15 matching lines @@
       c.data_shm_id, c.data_shm_offset, data_size);
 
   // All the normal glTexSubImage2D validation.
   error::Error error = error::kNoError;
   if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2DCHROMIUM",
       target, level, xoffset, yoffset, width, height, format, type, pixels)) {
     return error;
   }
 
   // Extra async validation.
-  Texture* texture = GetTextureInfoForTarget(target);
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  Texture* texture = texture_ref->texture();
   if (!ValidateAsyncTransfer(
          "glAsyncTexSubImage2DCHROMIUM", texture, target, level, pixels))
     return error::kNoError;
 
   // Guarantee async textures are always 'cleared' as follows:
   // - AsyncTexImage2D can not redefine an existing texture
   // - AsyncTexImage2D must initialize the entire image via non-null buffer.
   // - AsyncTexSubImage2D clears synchronously if not already cleared.
   // - Textures become immutable after an async call.
   // This way we know in all cases that an async texture is always clear.
   if (!texture->SafeToRenderFrom()) {
-    if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
+    if (!texture_manager()->ClearTextureLevel(this, texture_ref,
+                                              target, level)) {
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY,
           "glAsyncTexSubImage2DCHROMIUM", "dimensions too big");
       return error::kNoError;
     }
   }
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.data_shm_offset;
   uint32 shm_data_size = data_size;
 
   // Setup the parameters.
   AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
                                               width, height, format, type};
   AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
-  if (!texture->GetAsyncTransferState()) {
+  AsyncPixelTransferState* state = texture->GetAsyncTransferState();
+  if (!state) {
     // TODO(epenner): We may want to enforce exclusive use
     // of async APIs in which case this should become an error,
     // (the texture should have been async defined).
     AsyncTexImage2DParams define_params = {target, level,
                                                 0, 0, 0, 0, 0, 0};
     texture->GetLevelSize(target, level, &define_params.width,
                                          &define_params.height);
     texture->GetLevelType(target, level, &define_params.type,
                                          &define_params.internal_format);
     // Set up the async state if needed, and make the texture
     // immutable so the async state stays valid.
-    texture->SetAsyncTransferState(
-        make_scoped_ptr(
-            async_pixel_transfer_delegate_->CreatePixelTransferState(
-                texture->service_id(),
-                define_params)));
+    state = async_pixel_transfer_delegate_->CreatePixelTransferState(
+        texture->service_id(),
+        define_params);
+    texture_ref->SetAsyncTransferState(make_scoped_ptr(state));
     texture->SetImmutable(true);
   }
 
   async_pixel_transfer_delegate_->AsyncTexSubImage2D(
-      texture->GetAsyncTransferState(), tex_params, mem_params);
+      state, tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const cmds::WaitAsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
 
   if (GL_TEXTURE_2D != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_ENUM, "glWaitAsyncTexImage2DCHROMIUM", "target");
     return error::kNoError;
   }
-  Texture* texture = GetTextureInfoForTarget(target);
-  if (!texture) {
+  TextureRef* texture_ref = GetTextureInfoForTarget(target);
+  if (!texture_ref) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glWaitAsyncTexImage2DCHROMIUM", "unknown texture");
     return error::kNoError;
   }
-  async_pixel_transfer_delegate_->WaitForTransferCompletion(
-      texture->GetAsyncTransferState());
+  AsyncPixelTransferState* state =
+      texture_ref->texture()->GetAsyncTransferState();
+  if (!state) {

[piman, 2013/05/14 01:34:50]

Note: previous code could call WaitForTransferCompletion with a NULL state, and
crash.

+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_OPERATION,
+          "glWaitAsyncTexImage2DCHROMIUM", "No async transfer started");
+    return error::kNoError;
+  }
+  async_pixel_transfer_delegate_->WaitForTransferCompletion(state);
   ProcessFinishedAsyncTransfers();
   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