Add GLStreamTextureImage

gpu/command_buffer/service/texture_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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bits.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
+#include "gpu/command_buffer/service/gl_stream_texture_image.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_state_restorer.h"
 #include "ui/gl/gl_version_info.h"
 #include "ui/gl/trace_util.h"
 
 namespace gpu {
@@ skipping 869 matching lines @@
   }
 
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
+  info.stream_texture_image = 0;
   info.image_state = UNBOUND;
   info.internal_workaround = false;
 
   UpdateMipCleared(&info, width, height, cleared_rect);
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, depth, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
@@ skipping 416 matching lines @@
           return false;
       }
     }
   }
 
   UpdateMipCleared(&info, info.width, info.height,
                    gfx::Rect(info.width, info.height));
   return true;
 }
 
-void Texture::SetLevelImage(GLenum target,
-                            GLint level,
-                            gl::GLImage* image,
-                            ImageState state) {
+void Texture::SetLevelImageInternal(GLenum target,
+                                    GLint level,
+                                    gl::GLImage* image,
+                                    GLStreamTextureImage* stream_texture_image,
+                                    ImageState state) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
+  info.stream_texture_image = stream_texture_image;
   info.image_state = state;
 
   UpdateCanRenderCondition();
   UpdateHasImages();
 }
 
-gl::GLImage* Texture::GetLevelImage(GLint target,
-                                    GLint level,
-                                    ImageState* state) const {
+void Texture::SetLevelImage(GLenum target,
+                            GLint level,
+                            gl::GLImage* image,
+                            ImageState state) {
+  SetLevelImageInternal(target, level, image, nullptr, state);
+}
+
+void Texture::SetLevelStreamTextureImage(GLenum target,
+                                         GLint level,
+                                         GLStreamTextureImage* image,
+                                         ImageState state) {
+  SetLevelImageInternal(target, level, image, image, state);
+}
+
+const Texture::LevelInfo* Texture::GetLevelInfo(GLint target,
+                                                GLint level) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
-    if (info.target != 0) {
-      if (state)
-        *state = info.image_state;
-      return info.image.get();
-    }
+    if (info.target != 0)
+      return &info;
   }
   return NULL;
 }
 
+gl::GLImage* Texture::GetLevelImage(GLint target,
+                                    GLint level,
+                                    ImageState* state) const {
+  const LevelInfo* info = GetLevelInfo(target, level);
+  if (!info)
+    return nullptr;
+
+  if (state)
+    *state = info->image_state;
+  return info->image.get();
+}
+
 gl::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   return GetLevelImage(target, level, nullptr);
 }
 
+GLStreamTextureImage* Texture::GetLevelStreamTextureImage(GLint target,
+                                                          GLint level) const {
+  const LevelInfo* info = GetLevelInfo(target, level);
+  if (!info)
+    return nullptr;
+
+  return info->stream_texture_image.get();
+}
+
 void Texture::DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
                               uint64_t client_tracing_id,
                               const std::string& dump_name) const {
   for (uint32_t face_index = 0; face_index < face_infos_.size(); ++face_index) {
     const auto& level_infos = face_infos_[face_index].level_infos;
     for (uint32_t level_index = 0; level_index < level_infos.size();
          ++level_index) {
       // Skip levels with no size. Textures will have empty levels for all
       // potential mip levels which are not in use.
       if (!level_infos[level_index].estimated_size)
@@ skipping 475 matching lines @@
 
 void TextureManager::SetLevelImage(TextureRef* ref,
                                    GLenum target,
                                    GLint level,
                                    gl::GLImage* image,
                                    Texture::ImageState state) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(target, level, image, state);
 }
 
+void TextureManager::SetLevelStreamTextureImage(TextureRef* ref,
+                                                GLenum target,
+                                                GLint level,
+                                                GLStreamTextureImage* image,
+                                                Texture::ImageState state) {
+  DCHECK(ref);
+  ref->texture()->SetLevelStreamTextureImage(target, level, image, state);
+}
+
 size_t TextureManager::GetSignatureSize() const {
   return sizeof(TextureTag) + sizeof(TextureSignature);
 }
 
 void TextureManager::AddToSignature(
     TextureRef* ref,
     GLenum target,
     GLint level,
     std::string* signature) const {
   ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
@@ skipping 862 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu