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

gpu/command_buffer/service/framebuffer_manager.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/framebuffer_manager.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/framebuffer_completeness_cache.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
@@ skipping 69 matching lines @@
   size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return renderbuffer_->GetSignatureSize();
   }
 
   void AddToSignature(TextureManager* texture_manager,
                       std::string* signature) const override {
     DCHECK(signature);
     renderbuffer_->AddToSignature(signature);
   }
 
+  void OnWillRenderTo() const override {}
+  void OnDidRenderTo() const override {}
   bool FormsFeedbackLoop(TextureRef* /* texture */,
                          GLint /*level */) const override {
     return false;
   }
 
  protected:
   ~RenderbufferAttachment() override {}
 
  private:
   scoped_refptr<Renderbuffer> renderbuffer_;
@@ skipping 70 matching lines @@
   TextureRef* texture() const {
     return texture_ref_.get();
   }
 
   bool CanRenderTo() const override {
     return texture_ref_->texture()->CanRenderTo();
   }
 
   void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     texture_ref_->texture()->DetachFromFramebuffer();
+    framebuffer->OnTextureRefDetached(texture_ref_.get());
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
                               uint32 max_color_attachments) override {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
@@ skipping 14 matching lines @@
     return texture_manager->GetSignatureSize();
   }
 
   void AddToSignature(TextureManager* texture_manager,
                       std::string* signature) const override {
     DCHECK(signature);
     texture_manager->AddToSignature(
         texture_ref_.get(), target_, level_, signature);
   }
 
+  void OnWillRenderTo() const override {
+    texture_ref_->texture()->OnWillModifyPixels();
+  }
+
+  void OnDidRenderTo() const override {
+    texture_ref_->texture()->OnDidModifyPixels();
+  }
+
   bool FormsFeedbackLoop(TextureRef* texture, GLint level) const override {
     return texture == texture_ref_.get() && level == level_;
   }
 
  protected:
   ~TextureAttachment() override {}
 
  private:
   scoped_refptr<TextureRef> texture_ref_;
   GLenum target_;
   GLint level_;
   GLsizei samples_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 };
 
+FramebufferManager::TextureDetachObserver::TextureDetachObserver() {}
+
+FramebufferManager::TextureDetachObserver::~TextureDetachObserver() {}
+
 FramebufferManager::FramebufferManager(
     uint32 max_draw_buffers,
     uint32 max_color_attachments,
     ContextType context_type,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_combo_complete_cache)
     : framebuffer_state_change_count_(1),
       framebuffer_count_(0),
       have_context_(true),
       max_draw_buffers_(max_draw_buffers),
@@ skipping 451 matching lines @@
   }
   return NULL;
 }
 
 const Framebuffer::Attachment* Framebuffer::GetReadBufferAttachment() const {
   if (read_buffer_ == GL_NONE)
     return nullptr;
   return GetAttachment(read_buffer_);
 }
 
+void Framebuffer::OnTextureRefDetached(TextureRef* texture) {
+  manager_->OnTextureRefDetached(texture);
+}
+
+void Framebuffer::OnWillRenderTo(GLenum attachment) const {
+  for (AttachmentMap::const_iterator it = attachments_.begin();
+       it != attachments_.end(); ++it) {
+    if (attachment == 0 || attachment == it->first) {
+      it->second->OnWillRenderTo();
+    }
+  }
+}
+
+void Framebuffer::OnDidRenderTo(GLenum attachment) const {
+  for (AttachmentMap::const_iterator it = attachments_.begin();
+       it != attachments_.end(); ++it) {
+    if (attachment == 0 || attachment == it->first) {
+      it->second->OnDidRenderTo();
+    }
+  }
+}
+
 bool FramebufferManager::GetClientId(
     GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (FramebufferMap::const_iterator it = framebuffers_.begin();
        it != framebuffers_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
@@ skipping 17 matching lines @@
   framebuffer->MarkAsComplete(framebuffer_state_change_count_);
 }
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
+void FramebufferManager::OnTextureRefDetached(TextureRef* texture) {
+  for (TextureDetachObserverVector::iterator it =
+           texture_detach_observers_.begin();
+       it != texture_detach_observers_.end();
+       ++it) {
+    TextureDetachObserver* observer = *it;
+    observer->OnTextureRefDetachedFromFramebuffer(texture);
+  }
+}
+
 }  // namespace gles2
 }  // namespace gpu