Service/ClientDiscardableManager

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>
@@ skipping 10 matching lines @@
 #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 "gpu/command_buffer/service/progress_reporter.h"
+#include "gpu/command_buffer/service/service_discardable_manager.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"
 
 using base::trace_event::MemoryAllocatorDump;
 using base::trace_event::MemoryDumpLevelOfDetail;
 
 namespace gpu {
@@ skipping 393 matching lines @@
   DCHECK_EQ(0, num_uncleared_mips_);
   DCHECK_EQ(0, num_images_);
 
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
 
+  // Retreive any outstanding unlocked textures from the discardable manager so
+  // we can clean them up here.
+  discardable_manager_->OnTextureManagerDestruction(this);
+
   while (!textures_.empty()) {
     textures_.erase(textures_.begin());
     if (progress_reporter_)
       progress_reporter_->ReportProgress();
   }
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     default_textures_[ii] = NULL;
     if (progress_reporter_)
       progress_reporter_->ReportProgress();
   }
@@ skipping 1429 matching lines @@
 }
 
 TextureManager::TextureManager(MemoryTracker* memory_tracker,
                                FeatureInfo* feature_info,
                                GLint max_texture_size,
                                GLint max_cube_map_texture_size,
                                GLint max_rectangle_texture_size,
                                GLint max_3d_texture_size,
                                GLint max_array_texture_layers,
                                bool use_default_textures,
-                               ProgressReporter* progress_reporter)
+                               ProgressReporter* progress_reporter,
+                               ServiceDiscardableManager* discardable_manager)
     : memory_type_tracker_(new MemoryTypeTracker(memory_tracker)),
       memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       framebuffer_manager_(NULL),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
       max_rectangle_texture_size_(max_rectangle_texture_size),
       max_3d_texture_size_(max_3d_texture_size),
       max_array_texture_layers_(max_array_texture_layers),
       max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
                                      max_texture_size,
                                      max_texture_size,
                                      0)),
       max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               0)),
       max_3d_levels_(ComputeMipMapCount(GL_TEXTURE_3D,
                                         max_3d_texture_size,
                                         max_3d_texture_size,
                                         max_3d_texture_size)),
       use_default_textures_(use_default_textures),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       num_images_(0),
       texture_count_(0),
       have_context_(true),
       current_service_id_generation_(0),
-      progress_reporter_(progress_reporter) {
+      progress_reporter_(progress_reporter),
+      discardable_manager_(discardable_manager) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
 }
 
 bool TextureManager::Initialize() {
   // Reset PIXEL_UNPACK_BUFFER to avoid unrelated GL error on some GL drivers.
   if (feature_info_->gl_version_info().is_es3_capable) {
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
   }
@@ skipping 171 matching lines @@
                                   GLenum type,
                                   const gfx::Rect& cleared_rect) {
   DCHECK(gfx::Rect(width, height).Contains(cleared_rect));
   DCHECK(ref);
   Texture* texture = ref->texture();
 
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
   texture->SetLevelInfo(target, level, internal_format, width, height, depth,
                         border, format, type, cleared_rect);
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
+  discardable_manager_->OnTextureSizeChanged(ref->client_id(), this,
+                                             texture->estimated_size());
 }
 
 Texture* TextureManager::Produce(TextureRef* ref) {
   DCHECK(ref);
   return ref->texture();
 }
 
 TextureRef* TextureManager::Consume(
     GLuint client_id,
     Texture* texture) {
@@ skipping 73 matching lines @@
   DCHECK(result.second);
   return ref.get();
 }
 
 TextureRef* TextureManager::GetTexture(
     GLuint client_id) const {
   TextureMap::const_iterator it = textures_.find(client_id);
   return it != textures_.end() ? it->second.get() : NULL;
 }
 
+scoped_refptr<TextureRef> TextureManager::TakeTexture(GLuint client_id) {
+  auto it = textures_.find(client_id);
+  if (it == textures_.end())
+    return nullptr;
+
+  scoped_refptr<TextureRef> ref = it->second;
+  textures_.erase(it);
+  return ref;
+}
+
+void TextureManager::ReturnTexture(scoped_refptr<TextureRef> texture_ref) {
+  GLuint client_id = texture_ref->client_id();
+  textures_.emplace(client_id, std::move(texture_ref));
+}
+
 void TextureManager::RemoveTexture(GLuint client_id) {
   TextureMap::iterator it = textures_.find(client_id);
   if (it != textures_.end()) {
+    discardable_manager_->OnTextureDeleted(client_id, this);

[ericrk, 2017/05/10 21:36:03]

Don't love doing this both here and in StopTracking... but we can't only do it
in StopTracking, as if we hit this first, we won't have a client_id in
StopTracking. Can't only do it here, as we sometimes don't hit this
(destruction, maybe other places).

     it->second->reset_client_id();
     textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(TextureRef* ref) {
   Texture* texture = ref->texture();
   ++texture_count_;
   num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->SafeToRenderFrom())
@@ skipping 16 matching lines @@
   if (texture->HasImages()) {
     DCHECK_NE(0, num_images_);
     --num_images_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
+
+  if (ref->client_id())
+    discardable_manager_->OnTextureDeleted(ref->client_id(), this);
 }
 
 MemoryTypeTracker* TextureManager::GetMemTracker() {
   return memory_type_tracker_.get();
 }
 
 Texture* TextureManager::GetTextureForServiceId(GLuint service_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (TextureMap::const_iterator it = textures_.begin();
        it != textures_.end(); ++it) {
@@ skipping 1431 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu