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 3134 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 1762 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();
+  if (features().chromium_stream_texture && texture &&
+      texture->target() == GL_TEXTURE_EXTERNAL_OES) {
+    scoped_refptr<gfx::GLImage> stream_tex =
+        texture->GetLevelImage(GL_TEXTURE_EXTERNAL_OES, 0);
+    if (stream_tex.get())
+      stream_tex->UpdateTexImage();
   }
 }
 
 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;
   }
@@ skipping 3763 matching lines @@
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
       element_array_buffer ? element_array_buffer->service_id() : 0);
 }
 
 bool GLES2DecoderImpl::DoIsVertexArrayOES(GLuint client_id) {
   const VertexAttribManager* vao =
       GetVertexAttribManager(client_id);
   return vao && vao->IsValid() && !vao->IsDeleted();
 }
 
 error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(

[reveman, 2013/08/13 00:48:13]

Could this become CreateStreamImageCHROMIUM and require BindTexImageCHROMIUM to
be called for it to be bound to a texture?

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

Yes, I think that sounds good. But since it needs a lot of plumbing (or mostly
code auto-generation), I wanted to do it in a follow-up. (While I think this
patch might actually have to go into M30.)

     uint32 immediate_data_size,
     const cmds::CreateStreamTextureCHROMIUM& c) {
   if (!features().chromium_stream_texture) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glOpenStreamTextureCHROMIUM", "not supported.");
     return error::kNoError;
   }
 
   uint32 client_id = c.client_id;
   typedef cmds::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
 
   if (!result)
     return error::kOutOfBounds;
   *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);
+    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 191 matching lines @@
                                            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());
+    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