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 649 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);
+  // Notifies a potentially attached GLImage that we are about to draw with
+  // the texture.
+  void PrepareTexImageForDraw(Texture* texture);

[reveman, 2013/08/14 15:22:44]

PrepareTextureForRender? and maybe not be specific to textures with GLImage
attached but include all the logic from PrepareTexturesForRender.

[no sievers, 2013/08/14 18:16:48]

Done.

 
   // 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 2457 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();
+void GLES2DecoderImpl::PrepareTexImageForDraw(Texture* texture) {
+  if (texture) {
+    scoped_refptr<gfx::GLImage> image =
+        texture->GetLevelImage(texture->target(), 0);

[no sievers, 2013/08/14 04:01:24]

need to worry about multiple leves/images here?

+    if (image.get())
+      image->WillUseTexImage();
   }
 }
 
 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());
+          PrepareTexImageForDraw(texture->texture());
         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(texture->service_id());
 
-  GLuint object_id = stream_texture_manager()->CreateStreamTexture(
-      texture->service_id(), client_id);
-
-  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);

[reveman, 2013/08/14 15:22:44]

I thought we decided to track these separably from standard GLImages and use a
different Id namespace until the usage matches the basic concept of GLImage. I'm
ok with using the image manager in the meantime if you just add something like
ImageManager::Add/RemoveStreamImage() and LookupStreamImage().

[no sievers, 2013/08/14 18:16:48]

See change above. Now that the pattern matches better, can we track them
together?

+    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());
+    PrepareTexImageForDraw(source_texture);
+    scoped_refptr<gfx::GLImage> stream_tex =
+        source_texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0);
     if (!stream_tex) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "Stream texture lookup failed");
       return;
     }
     gfx::Size size = stream_tex->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
@@ skipping 745 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