Remove StreamTextureManager

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 35 matching lines @@
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
-#include "gpu/command_buffer/service/stream_texture.h"
-#include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_MACOSX)
@@ skipping 220 matching lines @@
  public:
   explicit ScopedGLErrorSuppressor(
       const char* function_name, GLES2DecoderImpl* decoder);
   ~ScopedGLErrorSuppressor();
  private:
   const char* function_name_;
   GLES2DecoderImpl* decoder_;
   DISALLOW_COPY_AND_ASSIGN(ScopedGLErrorSuppressor);
 };
 
-// Temporarily changes a decoder's bound 2D texture and restore it when this
+// Temporarily changes a decoder's bound texture and restore it when this
 // object goes out of scope. Also temporarily switches to using active texture
 // unit zero in case the client has changed that to something invalid.
-class ScopedTexture2DBinder {
+class ScopedTextureBinder {
  public:
-  ScopedTexture2DBinder(GLES2DecoderImpl* decoder, GLuint id);
-  ~ScopedTexture2DBinder();
+  ScopedTextureBinder(GLES2DecoderImpl* decoder, GLenum target, GLuint id);
+  ~ScopedTextureBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedTexture2DBinder);
+  DISALLOW_COPY_AND_ASSIGN(ScopedTextureBinder);
 };
 
 // Temporarily changes a decoder's bound render buffer and restore it when this
 // object goes out of scope.
 class ScopedRenderBufferBinder {
  public:
   ScopedRenderBufferBinder(GLES2DecoderImpl* decoder, GLuint id);
   ~ScopedRenderBufferBinder();
 
  private:
@@ skipping 306 matching lines @@
                                    uint32* service_texture_id) OVERRIDE;
 
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
   virtual base::TimeDelta GetTotalProcessingCommandsTime() OVERRIDE;
   virtual void AddProcessingCommandsTime(base::TimeDelta) OVERRIDE;
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
   void RestoreCurrentRenderbufferBindings();
-  void RestoreCurrentTexture2DBindings();
+  void RestoreCurrentTextureBindings(GLenum target);
 
   // Sets DEPTH_TEST, STENCIL_TEST and color mask for the current framebuffer.
   void ApplyDirtyState();
 
   // These check the state of the currently bound framebuffer or the
   // backbuffer if no framebuffer is bound.
   // If all_draw_buffers is false, only check with COLOR_ATTACHMENT0, otherwise
   // check with all attached and enabled color attachments.
   bool BoundFramebufferHasColorAttachmentWithAlpha(bool all_draw_buffers);
   bool BoundFramebufferHasDepthAttachment();
@@ skipping 71 matching lines @@
   }
 
   VertexArrayManager* vertex_array_manager() {
     return vertex_array_manager_.get();
   }
 
   MemoryTracker* memory_tracker() {
     return group_->memory_tracker();
   }
 
-  StreamTextureManager* stream_texture_manager() const {
-    return group_->stream_texture_manager();
-  }
-
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
@@ skipping 654 matching lines @@
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(
       const char* function_name, GLuint max_vertex_accessed, GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib);
 
-  // If texture is a stream texture, this will update the stream to the newest
-  // buffer.
-  void UpdateStreamTextureIfNeeded(Texture* texture);
-
   // Returns false if unrenderable textures were replaced.
   bool PrepareTexturesForRender();
   void RestoreStateForNonRenderableTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
       const char* function_name,
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
 
@@ skipping 343 matching lines @@
     : function_name_(function_name),
       decoder_(decoder) {
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(decoder_->GetErrorState(),
                                             function_name_);
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   ERRORSTATE_CLEAR_REAL_GL_ERRORS(decoder_->GetErrorState(), function_name_);
 }
 
-ScopedTexture2DBinder::ScopedTexture2DBinder(GLES2DecoderImpl* decoder,
-                                             GLuint id)
-    : decoder_(decoder) {
+ScopedTextureBinder::ScopedTextureBinder(GLES2DecoderImpl* decoder,
+                                         GLenum target,
+                                         GLuint id)
+    : decoder_(decoder),
+      target_(target) {
   ScopedGLErrorSuppressor suppressor(
-      "ScopedTexture2DBinder::ctor", decoder_);
+      "ScopedTextureBinder::ctor", decoder_);
 
   // TODO(apatrick): Check if there are any other states that need to be reset
   // before binding a new texture.
   glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, id);
+  glBindTexture(target, id);
 }
 
-ScopedTexture2DBinder::~ScopedTexture2DBinder() {
+ScopedTextureBinder::~ScopedTextureBinder() {
   ScopedGLErrorSuppressor suppressor(
-      "ScopedTexture2DBinder::dtor", decoder_);
-  decoder_->RestoreCurrentTexture2DBindings();
+      "ScopedTextureBinder::dtor", decoder_);
+  decoder_->RestoreCurrentTextureBindings(target_);
 }
 
 ScopedRenderBufferBinder::ScopedRenderBufferBinder(GLES2DecoderImpl* decoder,
                                                    GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(
       "ScopedRenderBufferBinder::ctor", decoder_);
   glBindRenderbufferEXT(GL_RENDERBUFFER, id);
 }
 
@@ skipping 107 matching lines @@
   // 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);
 }
 
 void BackTexture::Create() {
   ScopedGLErrorSuppressor suppressor("BackTexture::Create", decoder_);
   Destroy();
   glGenTextures(1, &id_);
-  ScopedTexture2DBinder binder(decoder_, id_);
+  ScopedTextureBinder binder(decoder_, GL_TEXTURE_2D, id_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   // TODO(apatrick): Attempt to diagnose crbug.com/97775. If SwapBuffers is
   // never called on an offscreen context, no data will ever be uploaded to the
   // saved offscreen color texture (it is deferred until to when SwapBuffers
   // is called). My idea is that some nvidia drivers might have a bug where
   // deleting a texture that has never been populated might cause a
   // crash.
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
   bytes_allocated_ = 16u * 16u * 4u;
   memory_tracker_.TrackMemAlloc(bytes_allocated_);
 }
 
 bool BackTexture::AllocateStorage(
     const gfx::Size& size, GLenum format, bool zero) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor("BackTexture::AllocateStorage", decoder_);
-  ScopedTexture2DBinder binder(decoder_, id_);
+  ScopedTextureBinder binder(decoder_, GL_TEXTURE_2D, id_);
   uint32 image_size = 0;
   GLES2Util::ComputeImageDataSizes(
       size.width(), size.height(), format, GL_UNSIGNED_BYTE, 8, &image_size,
       NULL, NULL);
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
   scoped_ptr<char[]> zero_data;
@@ skipping 19 matching lines @@
     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);
   ScopedGLErrorSuppressor suppressor("BackTexture::Copy", decoder_);
-  ScopedTexture2DBinder binder(decoder_, id_);
+  ScopedTextureBinder binder(decoder_, GL_TEXTURE_2D, id_);
   glCopyTexImage2D(GL_TEXTURE_2D,
                    0,  // level
                    format,
                    0, 0,
                    size.width(),
                    size.height(),
                    0);  // border
 }
 
 void BackTexture::Destroy() {
@@ skipping 905 matching lines @@
         state_.bound_read_framebuffer.get(),
         GetBackbufferServiceId());
     RebindCurrentFramebuffer(
         GL_DRAW_FRAMEBUFFER_EXT,
         state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   }
   OnFboChanged();
 }
 
-void GLES2DecoderImpl::RestoreCurrentTexture2DBindings() {
+void GLES2DecoderImpl::RestoreCurrentTextureBindings(GLenum target) {
   TextureUnit& info = state_.texture_units[0];
   GLuint last_id;
-  if (info.bound_texture_2d.get()) {
-    last_id = info.bound_texture_2d->service_id();
+  scoped_refptr<TextureRef> texture_ref;
+  switch (target) {
+    case GL_TEXTURE_2D:
+      texture_ref = info.bound_texture_2d;
+      break;
+    case GL_TEXTURE_CUBE_MAP:
+      texture_ref = info.bound_texture_cube_map;
+      break;
+    case GL_TEXTURE_EXTERNAL_OES:
+      texture_ref = info.bound_texture_external_oes;
+      break;
+    case GL_TEXTURE_RECTANGLE_ARB:
+      texture_ref = info.bound_texture_rectangle_arb;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  if (texture_ref.get()) {
+    last_id = texture_ref->service_id();
   } else {
     last_id = 0;
   }
 
-  glBindTexture(GL_TEXTURE_2D, last_id);
+  glBindTexture(target, last_id);
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     Framebuffer* framebuffer,
     GLenum target, const char* func_name) {
   if (!framebuffer) {
     if (backbuffer_needs_clear_bits_) {
       glClearColor(0, 0, 0, (GLES2Util::GetChannelsForFormat(
           offscreen_target_color_format_) & 0x0008) != 0 ? 0 : 1);
@@ skipping 951 matching lines @@
   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_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:
@@ skipping 1761 matching lines @@
     }
     // We know there will be no errors, because we only defer compilation on
     // shaders that were previously compiled successfully.
     program_manager()->ForceCompileShader(shader->deferred_compilation_source(),
                                           shader,
                                           translator,
                                           feature_info_.get());
   }
 }
 
-void GLES2DecoderImpl::UpdateStreamTextureIfNeeded(Texture* texture) {
-  if (texture && texture->IsStreamTexture()) {
-    DCHECK(stream_texture_manager());
-    StreamTexture* stream_tex =
-        stream_texture_manager()->LookupStreamTexture(texture->service_id());
-    if (stream_tex)
-      stream_tex->Update();
-  }
-}
-
 bool GLES2DecoderImpl::PrepareTexturesForRender() {
   DCHECK(state_.current_program.get());
   bool have_unrenderable_textures =
       texture_manager()->HaveUnrenderableTextures();
   if (!have_unrenderable_textures && !features().oes_egl_image_external) {
     return true;
   }
 
   bool textures_set = false;
   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];
         TextureRef* texture =
             texture_unit.GetInfoForSamplerType(uniform_info->type).get();
-        if (texture)
-          UpdateStreamTextureIfNeeded(texture->texture());
+        if (texture && texture->texture()) {
+          scoped_refptr<gfx::GLImage> image = texture->texture()->GetLevelImage(
+              texture->texture()->target(), 0);
+          if (image.get())
+            image->WillUseTexImage();
+        }
         if (have_unrenderable_textures &&
             (!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 3764 matching lines @@
   *result = GL_ZERO;
   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;
+  } else if (!texture->target()) {
+    texture_manager()->SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
   }
 
-  if (!stream_texture_manager())
-    return error::kInvalidArguments;
+  scoped_refptr<gfx::GLImage> image =
+      gfx::GLImage::CreateGLImageForStreamTexture();
 
-  GLuint object_id = stream_texture_manager()->CreateStreamTexture(
-      texture->service_id(), client_id);
+  {
+    ScopedTextureBinder binder(
+        this, GL_TEXTURE_EXTERNAL_OES, texture->service_id());
+    if (!image->BindTexImage())
+      image = NULL;
+  }
 
-  if (object_id) {
-    texture_manager()->SetStreamTexture(texture_ref, true);
+  uint32 image_id = 0;
+  if (image) {
+    image_id = group_->GetIdAllocator(id_namespaces::kImages)->AllocateID();
+    image_manager()->AddImage(image, image_id);
+    texture_manager()->SetLevelInfo(texture_ref,
+                                    GL_TEXTURE_EXTERNAL_OES,
+                                    0,
+                                    GL_RGBA,
+                                    0,
+                                    0,
+                                    1,
+                                    0,
+                                    GL_RGBA,
+                                    GL_UNSIGNED_BYTE,
+                                    true);
+    texture_manager()->SetLevelImage(
+        texture_ref, GL_TEXTURE_EXTERNAL_OES, 0, image);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY,
         "glCreateStreamTextureCHROMIUM", "failed to create platform texture.");
   }
 
-  *result = object_id;
+  *result = image_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const cmds::DestroyStreamTextureCHROMIUM& c) {
-  GLuint client_id = c.texture;
-  TextureRef* texture_ref = texture_manager()->GetTexture(client_id);
-  if (texture_ref && texture_manager()->IsStreamTextureOwner(texture_ref)) {
-    if (!stream_texture_manager())
-      return error::kInvalidArguments;
-
-    stream_texture_manager()->DestroyStreamTexture(texture_ref->service_id());
-    texture_manager()->SetStreamTexture(texture_ref, false);
+  GLuint image_id = c.texture;
+  if (image_id && image_manager()->LookupImage(image_id)) {
+    image_manager()->RemoveImage(image_id);
+    group_->GetIdAllocator(id_namespaces::kImages)->FreeID(image_id);
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
 
   return error::kNoError;
 }
 
 #if defined(OS_MACOSX)
@@ skipping 190 matching lines @@
     if (!texture_manager()->ValidForTarget(GL_TEXTURE_2D, level, source_width,
                                            source_height, 1)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureCHROMIUM", "Bad dimensions");
       return;
     }
   }
 
   if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {
-    UpdateStreamTextureIfNeeded(source_texture);
-    DCHECK(stream_texture_manager());
-    StreamTexture* stream_tex =
-        stream_texture_manager()->LookupStreamTexture(
-            source_texture->service_id());
-    if (!stream_tex) {
+    scoped_refptr<gfx::GLImage> image =
+        source_texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0);
+    if (!image) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "Stream texture lookup failed");
       return;
     }
-    gfx::Size size = stream_tex->GetSize();
+    image->WillUseTexImage();
+    gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "invalid streamtexture size");
       return;
     }
   }
 
@@ skipping 24 matching lines @@
       dest_internal_format != internal_format ||
       dest_type_previous != dest_type) {
     // Ensure that the glTexImage2D succeeds.
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyTextureCHROMIUM");
     glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
     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();
+      RestoreCurrentTextureBindings(GL_TEXTURE_2D);
       return;
     }
 
     texture_manager()->SetLevelInfo(
         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_ref, GL_TEXTURE_2D, level, true);
   }
@@ skipping 693 matching lines @@
   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