Simplify logic involving BackTexture.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 369 matching lines @@
  private:
   GLuint temp_texture_id_ = 0;
   GLuint temp_fbo_id_ = 0;
   std::unique_ptr<ScopedFrameBufferBinder> fbo_binder_;
   DISALLOW_COPY_AND_ASSIGN(ScopedFrameBufferReadPixelHelper);
 };
 
 // Encapsulates an OpenGL texture.
 class BackTexture {
  public:
-  explicit BackTexture(MemoryTracker* memory_tracker, ContextState* state);
+  explicit BackTexture(GLES2DecoderImpl* decoder);
   ~BackTexture();
 
   // Create a new render texture.
   void Create();
 
   // Set the initial size and format of a render texture or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format, bool zero);
 
   // Copy the contents of the currently bound frame buffer.
   void Copy(const gfx::Size& size, GLenum format);
 
   // Destroy the render texture. This must be explicitly called before
   // destroying this object.
   void Destroy();
 
   // Invalidate the texture. This can be used when a context is lost and it is
   // not possible to make it current in order to free the resource.
   void Invalidate();
 
+  scoped_refptr<TextureRef> texture_ref() { return texture_ref_; }
+
   GLuint id() const {
-    return id_;
+    return texture_ref_ ? texture_ref_->service_id() : 0;
   }
 
   gfx::Size size() const {
     return size_;
   }
 
  private:
   MemoryTypeTracker memory_tracker_;
-  ContextState* state_;
   size_t bytes_allocated_;
-  GLuint id_;
   gfx::Size size_;
+  GLES2DecoderImpl* decoder_;
+
+  scoped_refptr<TextureRef> texture_ref_;
+
   DISALLOW_COPY_AND_ASSIGN(BackTexture);
 };
 
 // Encapsulates an OpenGL render buffer of any format.
 class BackRenderbuffer {
  public:
   explicit BackRenderbuffer(
       RenderbufferManager* renderbuffer_manager,
       MemoryTracker* memory_tracker,
       ContextState* state);
@@ skipping 134 matching lines @@
                   bool offscreen,
                   const gfx::Size& offscreen_size,
                   const DisallowedFeatures& disallowed_features,
                   const ContextCreationAttribHelper& attrib_helper) override;
   void Destroy(bool have_context) override;
   void SetSurface(const scoped_refptr<gl::GLSurface>& surface) override;
   void ReleaseSurface() override;
   void TakeFrontBuffer(const Mailbox& mailbox) override;
   void ReturnFrontBuffer(const Mailbox& mailbox, bool is_lost) override;
   bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
-  void UpdateParentTextureInfo();
   bool MakeCurrent() override;
   GLES2Util* GetGLES2Util() override { return &util_; }
   gl::GLContext* GetGLContext() override { return context_.get(); }
   ContextGroup* GetContextGroup() override { return group_.get(); }
   Capabilities GetCapabilities() override;
   void RestoreState(const ContextState* prev_state) override;
 
   void RestoreActiveTexture() const override { state_.RestoreActiveTexture(); }
   void RestoreAllTextureUnitBindings(
       const ContextState* prev_state) const override {
@@ skipping 109 matching lines @@
                              GLbitfield mask,
                              GLenum filter);
 
   PathManager* path_manager() { return group_->path_manager(); }
 
  private:
   friend class ScopedFrameBufferBinder;
   friend class ScopedFrameBufferReadPixelHelper;
   friend class ScopedResolvedFrameBufferBinder;
   friend class BackFramebuffer;
+  friend class BackTexture;
 
   enum FramebufferOperation {
     kFramebufferDiscard,
     kFramebufferInvalidate,
     kFramebufferInvalidateSub
   };
 
   enum BindIndexedBufferFunctionType {
     kBindBufferBase,
     kBindBufferRange
@@ skipping 1323 matching lines @@
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
   GLboolean offscreen_target_buffer_preserved_;
 
   // The saved copy of the backbuffer after a call to SwapBuffers.
   std::unique_ptr<BackTexture> offscreen_saved_color_texture_;
 
   // For simplicity, |offscreen_saved_color_texture_| is always bound to
   // |offscreen_saved_frame_buffer_|.
   std::unique_ptr<BackFramebuffer> offscreen_saved_frame_buffer_;
-  scoped_refptr<TextureRef>
-      offscreen_saved_color_texture_info_;
 
   // When a client requests ownership of the swapped front buffer, all
   // information is saved in this structure, and |in_use| is set to true. When a
   // client releases ownership, |in_use| is set to false.
   //
   // An instance of this struct, with |in_use| = false may be reused instead of
   // making a new BackTexture.
   struct SavedBackTexture {
     std::unique_ptr<BackTexture> back_texture;
-    scoped_refptr<TextureRef> texture_ref;
     bool in_use;
   };
   std::vector<SavedBackTexture> saved_back_textures_;
 
   // If there's a SavedBackTexture that's not in use, takes that. Otherwise,
   // generates a new back texture.
   void CreateBackTexture();
   size_t create_back_texture_count_for_test_ = 0;
 
   // Releases all saved BackTextures that are not in use by a client.
   void ReleaseNotInUseBackTextures();
 
   // Releases all saved BackTextures.
-  void ReleaseAllBackTextures();
+  void ReleaseAllBackTextures(bool have_context);
 
   size_t GetSavedBackTextureCountForTest() override;
   size_t GetCreatedBackTextureCountForTest() override;
 
   // The copy that is used as the destination for multi-sample resolves.
   std::unique_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
   std::unique_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   std::unique_ptr<QueryManager> query_manager_;
@@ skipping 239 matching lines @@
       "ScopedResolvedFrameBufferBinder::ctor", decoder_->GetErrorState());
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,
                        decoder_->offscreen_target_frame_buffer_->id());
   GLuint targetid;
   if (internal) {
     if (!decoder_->offscreen_resolved_frame_buffer_.get()) {
       decoder_->offscreen_resolved_frame_buffer_.reset(
           new BackFramebuffer(decoder_));
       decoder_->offscreen_resolved_frame_buffer_->Create();
       decoder_->offscreen_resolved_color_texture_.reset(
-          new BackTexture(decoder->memory_tracker(), &decoder->state_));
+          new BackTexture(decoder));
       decoder_->offscreen_resolved_color_texture_->Create();
 
       DCHECK(decoder_->offscreen_saved_color_format_);
       decoder_->offscreen_resolved_color_texture_->AllocateStorage(
           decoder_->offscreen_size_, decoder_->offscreen_saved_color_format_,
           false);
       decoder_->offscreen_resolved_frame_buffer_->AttachRenderTexture(
           decoder_->offscreen_resolved_color_texture_.get());
       if (decoder_->offscreen_resolved_frame_buffer_->CheckStatus() !=
           GL_FRAMEBUFFER_COMPLETE) {
@@ skipping 63 matching lines @@
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                             temp_texture_id_, 0);
 }
 
 ScopedFrameBufferReadPixelHelper::~ScopedFrameBufferReadPixelHelper() {
   fbo_binder_.reset();
   glDeleteTextures(1, &temp_texture_id_);
   glDeleteFramebuffersEXT(1, &temp_fbo_id_);
 }
 
-BackTexture::BackTexture(
-    MemoryTracker* memory_tracker,
-    ContextState* state)
-    : memory_tracker_(memory_tracker),
-      state_(state),
+BackTexture::BackTexture(GLES2DecoderImpl* decoder)
+    : memory_tracker_(decoder->memory_tracker()),
       bytes_allocated_(0),
-      id_(0) {
-}
+      decoder_(decoder) {}
 
 BackTexture::~BackTexture() {
   // This does not destroy the render texture because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
-  DCHECK_EQ(id_, 0u);
+  DCHECK_EQ(id(), 0u);
 }
 
 void BackTexture::Create() {
-  DCHECK_EQ(id_, 0u);
+  DCHECK_EQ(id(), 0u);
   ScopedGLErrorSuppressor suppressor("BackTexture::Create",
-                                     state_->GetErrorState());
-  glGenTextures(1, &id_);
-  ScopedTextureBinder binder(state_, id_, GL_TEXTURE_2D);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+                                     decoder_->state_.GetErrorState());
+  GLuint id;
+  glGenTextures(1, &id);
+
+  GLenum target = GL_TEXTURE_2D;
+  ScopedTextureBinder binder(&decoder_->state_, id, target);
+
+  // No client id is necessary because this texture will never be directly
+  // accessed by a client, only indirectly via a mailbox.
+  texture_ref_ = TextureRef::Create(decoder_->texture_manager(), 0, id);
+  decoder_->texture_manager()->SetTarget(texture_ref_.get(), target);
+  decoder_->texture_manager()->SetParameteri(
+      "BackTexture::Create",
+      decoder_->GetErrorState(),
+      texture_ref_.get(),
+      GL_TEXTURE_MAG_FILTER,
+      GL_LINEAR);
+  decoder_->texture_manager()->SetParameteri(
+      "BackTexture::Create",
+      decoder_->GetErrorState(),
+      texture_ref_.get(),
+      GL_TEXTURE_MIN_FILTER,
+      GL_LINEAR);
+  decoder_->texture_manager()->SetParameteri(
+      "BackTexture::Create",
+      decoder_->GetErrorState(),
+      texture_ref_.get(),
+      GL_TEXTURE_WRAP_S,
+      GL_CLAMP_TO_EDGE);
+  decoder_->texture_manager()->SetParameteri(
+      "BackTexture::Create",
+      decoder_->GetErrorState(),
+      texture_ref_.get(),
+      GL_TEXTURE_WRAP_T,
+      GL_CLAMP_TO_EDGE);
 }
 
 bool BackTexture::AllocateStorage(
     const gfx::Size& size, GLenum format, bool zero) {
-  DCHECK_NE(id_, 0u);
+  DCHECK_NE(id(), 0u);
   ScopedGLErrorSuppressor suppressor("BackTexture::AllocateStorage",
-                                     state_->GetErrorState());
-  ScopedTextureBinder binder(state_, id_, GL_TEXTURE_2D);
+                                     decoder_->state_.GetErrorState());
+  ScopedTextureBinder binder(&decoder_->state_, id(), GL_TEXTURE_2D);
   uint32_t image_size = 0;
   GLES2Util::ComputeImageDataSizes(
       size.width(), size.height(), 1, format, GL_UNSIGNED_BYTE, 8, &image_size,
       NULL, NULL);
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
   std::unique_ptr<char[]> zero_data;
   if (zero) {
     zero_data.reset(new char[image_size]);
     memset(zero_data.get(), 0, image_size);
   }
 
   glTexImage2D(GL_TEXTURE_2D,
                0,  // mip level
                format,
                size.width(),
                size.height(),
                0,  // border
                format,
                GL_UNSIGNED_BYTE,
                zero_data.get());
 
   size_ = size;
+  decoder_->texture_manager()->SetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D,
+      0,  // level
+      GL_RGBA, size_.width(), size_.height(),
+      1,  // depth
+      0,  // border
+      GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(size_));
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     memory_tracker_.TrackMemFree(bytes_allocated_);
     bytes_allocated_ = image_size;
     memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   return success;
 }
 
 void BackTexture::Copy(const gfx::Size& size, GLenum format) {
-  DCHECK_NE(id_, 0u);
+  DCHECK_NE(id(), 0u);
   ScopedGLErrorSuppressor suppressor("BackTexture::Copy",
-                                     state_->GetErrorState());
-  ScopedTextureBinder binder(state_, id_, GL_TEXTURE_2D);
+                                     decoder_->state_.GetErrorState());
+  ScopedTextureBinder binder(&decoder_->state_, id(), GL_TEXTURE_2D);
   glCopyTexImage2D(GL_TEXTURE_2D,
                    0,  // level
                    format,
                    0, 0,
                    size.width(),
                    size.height(),
                    0);  // border
 }
 
 void BackTexture::Destroy() {
-  if (id_ != 0) {
+  if (texture_ref_) {
     ScopedGLErrorSuppressor suppressor("BackTexture::Destroy",
-                                       state_->GetErrorState());
-    glDeleteTextures(1, &id_);
-    id_ = 0;
+                                       decoder_->state_.GetErrorState());
+    texture_ref_ = nullptr;
   }
   memory_tracker_.TrackMemFree(bytes_allocated_);
   bytes_allocated_ = 0;
 }
 
 void BackTexture::Invalidate() {
-  id_ = 0;
+  if (texture_ref_) {
+    texture_ref_->ForceContextLost();
+    texture_ref_ = nullptr;
+  }
 }
 
 BackRenderbuffer::BackRenderbuffer(
     RenderbufferManager* renderbuffer_manager,
     MemoryTracker* memory_tracker,
     ContextState* state)
     : renderbuffer_manager_(renderbuffer_manager),
       memory_tracker_(memory_tracker),
       state_(state),
       bytes_allocated_(0),
@@ skipping 455 matching lines @@
     offscreen_target_frame_buffer_->Create();
     // Due to GLES2 format limitations, either the color texture (for
     // non-multisampling) or the color render buffer (for multisampling) will be
     // attached to the offscreen frame buffer.  The render buffer has more
     // limited formats available to it, but the texture can't do multisampling.
     if (IsOffscreenBufferMultisampled()) {
       offscreen_target_color_render_buffer_.reset(new BackRenderbuffer(
           renderbuffer_manager(), memory_tracker(), &state_));
       offscreen_target_color_render_buffer_->Create();
     } else {
-      offscreen_target_color_texture_.reset(new BackTexture(
-          memory_tracker(), &state_));
+      offscreen_target_color_texture_.reset(new BackTexture(this));
       offscreen_target_color_texture_->Create();
     }
     offscreen_target_depth_render_buffer_.reset(new BackRenderbuffer(
         renderbuffer_manager(), memory_tracker(), &state_));
     offscreen_target_depth_render_buffer_->Create();
     offscreen_target_stencil_render_buffer_.reset(new BackRenderbuffer(
         renderbuffer_manager(), memory_tracker(), &state_));
     offscreen_target_stencil_render_buffer_->Create();
 
     // Create the saved offscreen texture. The target frame buffer is copied
     // here when SwapBuffers is called.
     offscreen_saved_frame_buffer_.reset(new BackFramebuffer(this));
     offscreen_saved_frame_buffer_->Create();
     //
-    offscreen_saved_color_texture_.reset(new BackTexture(
-        memory_tracker(), &state_));
+    offscreen_saved_color_texture_.reset(new BackTexture(this));
     offscreen_saved_color_texture_->Create();
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     if (!ResizeOffscreenFrameBuffer(offscreen_size)) {
       LOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy(true);
       return false;
     }
 
@@ skipping 1109 matching lines @@
       break;
     default:
       // Caller is responsible for breaking GL_DEPTH_STENCIL into GL_DEPTH and
       // GL_STENCIL.
       NOTREACHED();
   }
   framebuffer->MarkAttachmentAsCleared(
       renderbuffer_manager(), texture_manager(), attachment, true);
 }
 
-void GLES2DecoderImpl::UpdateParentTextureInfo() {
-  if (!offscreen_saved_color_texture_info_.get())
-    return;
-  GLenum target = offscreen_saved_color_texture_info_->texture()->target();
-  glBindTexture(target, offscreen_saved_color_texture_info_->service_id());
-  texture_manager()->SetLevelInfo(
-      offscreen_saved_color_texture_info_.get(), GL_TEXTURE_2D,
-      0,  // level
-      GL_RGBA, offscreen_size_.width(), offscreen_size_.height(),
-      1,  // depth
-      0,  // border
-      GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect(offscreen_size_));
-  texture_manager()->SetParameteri(
-      "UpdateParentTextureInfo",
-      GetErrorState(),
-      offscreen_saved_color_texture_info_.get(),
-      GL_TEXTURE_MAG_FILTER,
-      GL_LINEAR);
-  texture_manager()->SetParameteri(
-      "UpdateParentTextureInfo",
-      GetErrorState(),
-      offscreen_saved_color_texture_info_.get(),
-      GL_TEXTURE_MIN_FILTER,
-      GL_LINEAR);
-  texture_manager()->SetParameteri(
-      "UpdateParentTextureInfo",
-      GetErrorState(),
-      offscreen_saved_color_texture_info_.get(),
-      GL_TEXTURE_WRAP_S,
-      GL_CLAMP_TO_EDGE);
-  texture_manager()->SetParameteri(
-      "UpdateParentTextureInfo",
-      GetErrorState(),
-      offscreen_saved_color_texture_info_.get(),
-      GL_TEXTURE_WRAP_T,
-      GL_CLAMP_TO_EDGE);
-  TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
-      &state_, target);
-  glBindTexture(target, texture_ref ? texture_ref->service_id() : 0);
-}
-
 Logger* GLES2DecoderImpl::GetLogger() {
   return &logger_;
 }
 
 void GLES2DecoderImpl::BeginDecoding() {
   gpu_tracer_->BeginDecoding();
   gpu_trace_commands_ = gpu_tracer_->IsTracing() && *gpu_decoder_category_;
   gpu_debug_commands_ = log_commands() || debug() || gpu_trace_commands_;
   query_manager_->ProcessFrameBeginUpdates();
 }
@@ skipping 75 matching lines @@
   state_.bound_pixel_unpack_buffer = nullptr;
   state_.bound_transform_feedback_buffer = nullptr;
   state_.bound_uniform_buffer = nullptr;
   framebuffer_state_.bound_read_framebuffer = nullptr;
   framebuffer_state_.bound_draw_framebuffer = nullptr;
   state_.bound_renderbuffer = nullptr;
   state_.bound_transform_feedback = nullptr;
   state_.default_transform_feedback = nullptr;
   state_.indexed_uniform_buffer_bindings = nullptr;
 
-  if (offscreen_saved_color_texture_info_.get()) {
-    DCHECK(offscreen_saved_color_texture_);
-    DCHECK_EQ(offscreen_saved_color_texture_info_->service_id(),
-              offscreen_saved_color_texture_->id());
-    offscreen_saved_color_texture_->Invalidate();
-    offscreen_saved_color_texture_info_ = NULL;
-  }
-  ReleaseAllBackTextures();
+  ReleaseAllBackTextures(have_context);
   if (have_context) {
     if (apply_framebuffer_attachment_cmaa_intel_.get()) {
       apply_framebuffer_attachment_cmaa_intel_->Destroy();
       apply_framebuffer_attachment_cmaa_intel_.reset();
     }
 
     if (copy_tex_image_blit_.get()) {
       copy_tex_image_blit_->Destroy();
       copy_tex_image_blit_.reset();
     }
@@ skipping 146 matching lines @@
   context_->ReleaseCurrent(surface_.get());
   surface_ = nullptr;
 }
 
 void GLES2DecoderImpl::TakeFrontBuffer(const Mailbox& mailbox) {
   if (!offscreen_saved_color_texture_.get()) {
     DLOG(ERROR) << "Called TakeFrontBuffer on a non-offscreen context";
     return;
   }
 
-  if (!offscreen_saved_color_texture_info_.get()) {
-    GLuint service_id = offscreen_saved_color_texture_->id();
-    offscreen_saved_color_texture_info_ = TextureRef::Create(
-        texture_manager(), 0, service_id);
-    texture_manager()->SetTarget(offscreen_saved_color_texture_info_.get(),
-                                 GL_TEXTURE_2D);
-    UpdateParentTextureInfo();
-  }
-
   mailbox_manager()->ProduceTexture(
-      mailbox, offscreen_saved_color_texture_info_->texture());
+      mailbox, offscreen_saved_color_texture_->texture_ref()->texture());
 
   // Save the BackTexture and TextureRef. There's no need to update
   // |offscreen_saved_frame_buffer_| since CreateBackTexture() will take care of
   // that.
   SavedBackTexture save;
   save.back_texture.swap(offscreen_saved_color_texture_);
-  save.texture_ref = offscreen_saved_color_texture_info_;
-  offscreen_saved_color_texture_info_ = nullptr;
   save.in_use = true;
   saved_back_textures_.push_back(std::move(save));
 
   CreateBackTexture();
 }
 
 void GLES2DecoderImpl::ReturnFrontBuffer(const Mailbox& mailbox, bool is_lost) {
   Texture* texture = mailbox_manager()->ConsumeTexture(mailbox);
   for (auto it = saved_back_textures_.begin(); it != saved_back_textures_.end();
        ++it) {
-    if (texture != it->texture_ref->texture())
+    if (texture != it->back_texture->texture_ref()->texture())
       continue;
 
     if (is_lost || it->back_texture->size() != offscreen_size_) {
       it->back_texture->Invalidate();
       saved_back_textures_.erase(it);
       return;
     }
 
     it->in_use = false;
     return;
   }
 
   DLOG(ERROR) << "Attempting to return a frontbuffer that was not saved.";
 }
 
 void GLES2DecoderImpl::CreateBackTexture() {
   for (auto it = saved_back_textures_.begin(); it != saved_back_textures_.end();
        ++it) {
     if (it->in_use)
       continue;
 
     if (it->back_texture->size() != offscreen_size_)
       continue;
     offscreen_saved_color_texture_ = std::move(it->back_texture);
-    offscreen_saved_color_texture_info_ = it->texture_ref;
     offscreen_saved_frame_buffer_->AttachRenderTexture(
         offscreen_saved_color_texture_.get());
     saved_back_textures_.erase(it);
     return;
   }
 
   ++create_back_texture_count_for_test_;
-  offscreen_saved_color_texture_.reset(
-      new BackTexture(memory_tracker(), &state_));
+  offscreen_saved_color_texture_.reset(new BackTexture(this));
   offscreen_saved_color_texture_->Create();
   offscreen_saved_color_texture_->AllocateStorage(
       offscreen_size_, offscreen_saved_color_format_, false);
   offscreen_saved_frame_buffer_->AttachRenderTexture(
       offscreen_saved_color_texture_.get());
 }
 
 void GLES2DecoderImpl::ReleaseNotInUseBackTextures() {
   for (auto& saved_back_texture : saved_back_textures_) {
     if (!saved_back_texture.in_use)
-      saved_back_texture.back_texture->Invalidate();
+      saved_back_texture.back_texture->Destroy();
   }
-
   auto to_remove =
       std::remove_if(saved_back_textures_.begin(), saved_back_textures_.end(),
                      [](const SavedBackTexture& saved_back_texture) {
                        return !saved_back_texture.in_use;
                      });
   saved_back_textures_.erase(to_remove, saved_back_textures_.end());
 }
 
-void GLES2DecoderImpl::ReleaseAllBackTextures() {
+void GLES2DecoderImpl::ReleaseAllBackTextures(bool have_context) {
   for (auto& saved_back_texture : saved_back_textures_) {
-    // The texture will be destroyed by texture_ref's destructor.
-    DCHECK(saved_back_texture.texture_ref);
-    saved_back_texture.back_texture->Invalidate();
+    if (have_context)
+      saved_back_texture.back_texture->Destroy();
+    else
+      saved_back_texture.back_texture->Invalidate();
   }
   saved_back_textures_.clear();
 }
 
 size_t GLES2DecoderImpl::GetSavedBackTextureCountForTest() {
   return saved_back_textures_.size();
 }
 
 size_t GLES2DecoderImpl::GetCreatedBackTextureCountForTest() {
   return create_back_texture_count_for_test_;
@@ skipping 8881 matching lines @@
         {
           ScopedFrameBufferBinder binder(this,
                                          offscreen_saved_frame_buffer_->id());
           glClearColor(0, 0, 0, 0);
           state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
           state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
           glClear(GL_COLOR_BUFFER_BIT);
           RestoreClearState();
         }
       }
-
-      UpdateParentTextureInfo();
     }
 
     if (offscreen_size_.width() == 0 || offscreen_size_.height() == 0)
       return;
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoSwapBuffers", GetErrorState());
 
     if (IsOffscreenBufferMultisampled()) {
       // For multisampled buffers, resolve the frame buffer.
       ScopedResolvedFrameBufferBinder binder(this, true, false);
     } else {
       ScopedFrameBufferBinder binder(this,
                                      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_->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());
         offscreen_saved_frame_buffer_->AttachRenderTexture(
             offscreen_saved_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 3537 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu