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 656 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;
+
   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(offscreen_saved_color_texture_info_->target(),
-                  texture ? texture->service_id() : 0);
+    TextureRef* texture_ref = GetTextureInfoForTarget(target);
+    glBindTexture(target, texture_ref ? texture_ref->service_id() : 0);
   } 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 444 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();
   }
 
   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 438 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 536 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,
         "glCreateStreamTextureCHROMIUM",
         "is already bound to incompatible target.");
     return error::kNoError;
   }
 
   if (!stream_texture_manager_)
     return error::kInvalidArguments;
 
   GLuint object_id = stream_texture_manager_->CreateStreamTexture(
       texture->service_id(), client_id);
 
   if (object_id) {
-    texture_manager()->SetStreamTexture(texture, true);
+    texture_manager()->SetStreamTexture(texture_ref, true);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY,
         "glCreateStreamTextureCHROMIUM", "failed to create platform texture.");
   }
 
   *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_manager()->SetStreamTexture(texture, false);
+    stream_texture_manager_->DestroyStreamTexture(texture_ref->service_id());
+    texture_manager()->SetStreamTexture(texture_ref, 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 71 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) {
+      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