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

gpu/command_buffer/service/framebuffer_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 34 matching lines @@
     virtual bool IsTexture(TextureRef* texture) const = 0;
     virtual bool IsRenderbuffer(
         Renderbuffer* renderbuffer) const = 0;
     virtual bool CanRenderTo() const = 0;
     virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const = 0;
     virtual bool ValidForAttachmentType(
         GLenum attachment_type, uint32 max_color_attachments) = 0;
     virtual size_t GetSignatureSize(TextureManager* texture_manager) const = 0;
     virtual void AddToSignature(
         TextureManager* texture_manager, std::string* signature) const = 0;
+    virtual void OnWillRenderTo() const = 0;
+    virtual void OnDidRenderTo() const = 0;
     virtual bool FormsFeedbackLoop(TextureRef* texture, GLint level) const = 0;
 
    protected:
     friend class base::RefCounted<Attachment>;
     virtual ~Attachment() {}
   };
 
   Framebuffer(FramebufferManager* manager, GLuint service_id);
 
   GLuint service_id() const {
@@ skipping 86 matching lines @@
   // Clear all the active INT or UINT type color buffers to (0, 0, 0, 0).
   void ClearIntegerBuffers();
 
   // Return true if any draw buffers has an alpha channel.
   bool HasAlphaMRT() const;
 
   // Return false if any two active color attachments have different internal
   // formats.
   bool HasSameInternalFormatsMRT() const;
 
+  void OnTextureRefDetached(TextureRef* texture);
+
+  // If attachment is 0, apply to all attachments; otherwise, apply only to
+  // the specified attachment.
+  void OnWillRenderTo(GLenum attachment) const;
+  void OnDidRenderTo(GLenum attachment) const;
+
   void set_read_buffer(GLenum read_buffer) {
     read_buffer_ = read_buffer;
   }
 
   GLenum read_buffer() const {
     return read_buffer_;
   }
 
  private:
   friend class FramebufferManager;
@@ skipping 55 matching lines @@
 
   // The currently bound framebuffers
   scoped_refptr<Framebuffer> bound_read_framebuffer;
   scoped_refptr<Framebuffer> bound_draw_framebuffer;
 };
 
 // This class keeps track of the frambebuffers and their attached renderbuffers
 // so we can correctly clear them.
 class GPU_EXPORT FramebufferManager {
  public:
+  class GPU_EXPORT TextureDetachObserver {
+   public:
+    TextureDetachObserver();
+    virtual ~TextureDetachObserver();
+
+    virtual void OnTextureRefDetachedFromFramebuffer(TextureRef* texture) = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(TextureDetachObserver);
+  };
+
   FramebufferManager(uint32 max_draw_buffers,
                      uint32 max_color_attachments,
                      ContextType context_type,
                      const scoped_refptr<FramebufferCompletenessCache>&
                          framebuffer_combo_complete_cache);
   ~FramebufferManager();
 
   // Must call before destruction.
   void Destroy(bool have_context);
 
@@ skipping 17 matching lines @@
   void MarkAsComplete(Framebuffer* framebuffer);
 
   bool IsComplete(Framebuffer* framebuffer);
 
   void IncFramebufferStateChangeCount() {
     // make sure this is never 0.
     framebuffer_state_change_count_ =
         (framebuffer_state_change_count_ + 1) | 0x80000000U;
   }
 
+  void AddObserver(TextureDetachObserver* observer) {
+    texture_detach_observers_.push_back(observer);
+  }
+
+  void RemoveObserver(TextureDetachObserver* observer) {
+    texture_detach_observers_.erase(
+        std::remove(texture_detach_observers_.begin(),
+                    texture_detach_observers_.end(),
+                    observer),
+        texture_detach_observers_.end());
+  }
+
   ContextType context_type() const { return context_type_; }
 
  private:
   friend class Framebuffer;
 
   void StartTracking(Framebuffer* framebuffer);
   void StopTracking(Framebuffer* framebuffer);
 
+  void OnTextureRefDetached(TextureRef* texture);
+
   FramebufferCompletenessCache* GetFramebufferComboCompleteCache() {
     return framebuffer_combo_complete_cache_.get();
   }
 
   // Info for each framebuffer in the system.
   typedef base::hash_map<GLuint, scoped_refptr<Framebuffer> >
       FramebufferMap;
   FramebufferMap framebuffers_;
 
   // Incremented anytime anything changes that might effect framebuffer
   // state.
   unsigned framebuffer_state_change_count_;
 
   // Counts the number of Framebuffer allocated with 'this' as its manager.
   // Allows to check no Framebuffer will outlive this.
   unsigned int framebuffer_count_;
 
   bool have_context_;
 
   uint32 max_draw_buffers_;
   uint32 max_color_attachments_;
 
   ContextType context_type_;
 
+  typedef std::vector<TextureDetachObserver*> TextureDetachObserverVector;
+  TextureDetachObserverVector texture_detach_observers_;
+
   scoped_refptr<FramebufferCompletenessCache> framebuffer_combo_complete_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(FramebufferManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_FRAMEBUFFER_MANAGER_H_