Re-land: ui: Move GLImage::BindTexImage fallback from GLImage implementations to GLES2CmdDecoder.

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 374 matching lines @@
 Texture::LevelInfo::LevelInfo()
     : target(0),
       level(-1),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
       type(0),
-      estimated_size(0) {
-}
+      image_state(UNBOUND),
+      estimated_size(0) {}
 
 Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
     : cleared_rect(rhs.cleared_rect),
       target(rhs.target),
       level(rhs.level),
       internal_format(rhs.internal_format),
       width(rhs.width),
       height(rhs.height),
       depth(rhs.depth),
       border(rhs.border),
       format(rhs.format),
       type(rhs.type),
       image(rhs.image),
-      estimated_size(rhs.estimated_size) {
-}
+      image_state(rhs.image_state),
+      estimated_size(rhs.estimated_size) {}
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
 Texture::FaceInfo::FaceInfo()
     : num_mip_levels(0) {
 }
 
 Texture::FaceInfo::~FaceInfo() {
 }
@@ skipping 403 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.image_state = UNBOUND;
 
   UpdateMipCleared(&info, width, height, cleared_rect);
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
@@ skipping 385 matching lines @@
       if (!cleared)
         return false;
     }
   }
 
   UpdateMipCleared(&info, info.width, info.height,
                    gfx::Rect(info.width, info.height));
   return true;
 }
 
-void Texture::SetLevelImage(
-    const FeatureInfo* feature_info,
-    GLenum target,
-    GLint level,
-    gfx::GLImage* image) {
+void Texture::SetLevelImage(GLenum target,
+                            GLint level,
+                            gfx::GLImage* 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.image_state = state;
   UpdateCanRenderCondition();
   UpdateHasImages();
-
-  // TODO(ericrk): Images may have complex sizing not accounted for by

[ericrk, 2015/10/19 17:15:45]

With current logic, estimated_size_ will always act as though there is a single
texture bound at each level, independent of whether there is an image bound as
well. Is that the pattern we want to go for now - might be fine - we'd be
treating the GLImages as though they aren't part of the texture I guess?

[reveman, 2015/10/19 19:12:29]

Yes, that's the idea. estimated_size_ is the size for each level independent of
the images. If an image is bound, then that replaces the storage of the texture
and estimated_size_ should not be reported in the dumps. In all other cases
(UNBOUND/COPIED), estimated_size_ should be reported.

-  // |estimated_size_|, we should add logic here to update |estimated_size_|
-  // based on the new GLImage. crbug.com/526298
 }
 
-gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
+gfx::GLImage* Texture::GetLevelImage(GLint target,
+                                     GLint level,
+                                     ImageState* state) 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();
     }
   }
   return NULL;
 }
 
-void Texture::OnWillModifyPixels() {
-  gfx::GLImage* image = GetLevelImage(target(), 0);
-  if (image)
-    image->WillModifyTexImage();
-}
-
-void Texture::OnDidModifyPixels() {
-  gfx::GLImage* image = GetLevelImage(target(), 0);
-  if (image)
-    image->DidModifyTexImage();
+gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
+  return GetLevelImage(target, level, nullptr);
 }
 
 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)
         continue;
 
+      // If a level has a GLImage, ask the GLImage to dump itself.
       if (level_infos[level_index].image) {
-        // If a level is backed by a GLImage, ask the GLImage to dump itself.
         level_infos[level_index].image->OnMemoryDump(
             pmd, client_tracing_id,
             base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
                                face_index, level_index));
-      } else {
-        // If a level is not backed by a GLImage, create a simple dump.
+      }
+
+      // If a level does not have a GLImage bound to it, then dump the
+      // texture allocation also as the storage is not provided by the
+      // GLImage in that case.
+      if (level_infos[level_index].image_state != BOUND) {
         base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
             base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
                                face_index, level_index));
         dump->AddScalar(
             base::trace_event::MemoryAllocatorDump::kNameSize,
             base::trace_event::MemoryAllocatorDump::kUnitsBytes,
             static_cast<uint64_t>(level_infos[level_index].estimated_size));
       }
     }
   }
@@ skipping 395 matching lines @@
                                            GLsizei depth) {
   switch (target) {
     case GL_TEXTURE_EXTERNAL_OES:
       return 1;
     default:
       return 1 +
              base::bits::Log2Floor(std::max(std::max(width, height), depth));
   }
 }
 
-void TextureManager::SetLevelImage(
-    TextureRef* ref,
-    GLenum target,
-    GLint level,
-    gfx::GLImage* image) {
+void TextureManager::SetLevelImage(TextureRef* ref,
+                                   GLenum target,
+                                   GLint level,
+                                   gfx::GLImage* image,
+                                   Texture::ImageState state) {
   DCHECK(ref);
-  ref->texture()->SetLevelImage(feature_info_.get(), target, level, image);
+  ref->texture()->SetLevelImage(target, level, image, state);
 }
 
 size_t TextureManager::GetSignatureSize() const {
   return sizeof(TextureTag) + sizeof(TextureSignature);
 }
 
 void TextureManager::AddToSignature(
     TextureRef* ref,
     GLenum target,
     GLint level,
@@ skipping 421 matching lines @@
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
 
   // Dump all sub-levels held by the texture. They will appear below the main
   // gl/textures/client_X/texture_Y dump.
   ref->texture()->DumpLevelMemory(pmd, memory_tracker_->ClientTracingId(),
                                   dump_name);
 }
 
 }  // namespace gles2
 }  // namespace gpu