Ping watchdog thread during GpuChannel destruction

gpu/command_buffer/service/context_group.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/context_group.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/path_manager.h"
 #include "gpu/command_buffer/service/program_manager.h"
+#include "gpu/command_buffer/service/progress_reporter.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 namespace gles2 {
@@ skipping 27 matching lines @@
 
 ContextGroup::ContextGroup(
     const GpuPreferences& gpu_preferences,
     const scoped_refptr<MailboxManager>& mailbox_manager,
     const scoped_refptr<MemoryTracker>& memory_tracker,
     const scoped_refptr<ShaderTranslatorCache>& shader_translator_cache,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_completeness_cache,
     const scoped_refptr<FeatureInfo>& feature_info,
     bool bind_generates_resource,
-    gpu::ImageFactory* image_factory)
+    gpu::ImageFactory* image_factory,
+    ProgressReporter* progress_reporter)
     : gpu_preferences_(gpu_preferences),
       mailbox_manager_(mailbox_manager),
       memory_tracker_(memory_tracker),
       shader_translator_cache_(shader_translator_cache),
 #if defined(OS_MACOSX)
       // Framebuffer completeness is not cacheable on OS X because of dynamic
       // graphics switching.
       // http://crbug.com/180876
       // TODO(tobiasjs): determine whether GPU switching is possible
       // programmatically, rather than just hardcoding this behaviour
@@ skipping 17 matching lines @@
       max_vertex_output_components_(0u),
       max_fragment_input_components_(0u),
       min_program_texel_offset_(0),
       max_program_texel_offset_(0),
       max_transform_feedback_separate_attribs_(0u),
       max_uniform_buffer_bindings_(0u),
       uniform_buffer_offset_alignment_(1u),
       program_cache_(NULL),
       feature_info_(feature_info),
       image_factory_(image_factory),
-      passthrough_resources_(new PassthroughResources) {
+      passthrough_resources_(new PassthroughResources),
+      progress_reporter_(progress_reporter) {
   {
     DCHECK(feature_info_);
     if (!mailbox_manager_.get())
       mailbox_manager_ = new MailboxManagerImpl;
     transfer_buffer_manager_ = new TransferBufferManager(memory_tracker_.get());
   }
 }
 
 bool ContextGroup::Initialize(GLES2Decoder* decoder,
                               ContextType context_type,
@@ skipping 88 matching lines @@
   }
 
   buffer_manager_.reset(
       new BufferManager(memory_tracker_.get(), feature_info_.get()));
   framebuffer_manager_.reset(
       new FramebufferManager(max_draw_buffers_, max_color_attachments_,
                              framebuffer_completeness_cache_));
   renderbuffer_manager_.reset(new RenderbufferManager(
       memory_tracker_.get(), max_renderbuffer_size, max_samples,
       feature_info_.get()));
-  shader_manager_.reset(new ShaderManager());
+  shader_manager_.reset(new ShaderManager(progress_reporter_));
   sampler_manager_.reset(new SamplerManager(feature_info_.get()));
 
   // Lookup GL things we need to know.
   const GLint kGLES2RequiredMinimumVertexAttribs = 8u;
   if (!QueryGLFeatureU(
       GL_MAX_VERTEX_ATTRIBS, kGLES2RequiredMinimumVertexAttribs,
       &max_vertex_attribs_)) {
     DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
                 << "vertex attributes supported (" << max_vertex_attribs_
                 << ", should be " << kGLES2RequiredMinimumVertexAttribs << ").";
@@ skipping 66 matching lines @@
 
   if (feature_info_->workarounds().max_texture_size) {
     max_texture_size = std::min(
         max_texture_size,
         feature_info_->workarounds().max_texture_size);
     max_rectangle_texture_size = std::min(
         max_rectangle_texture_size,
         feature_info_->workarounds().max_texture_size);
   }
 
-  texture_manager_.reset(new TextureManager(memory_tracker_.get(),
-                                            feature_info_.get(),
-                                            max_texture_size,
-                                            max_cube_map_texture_size,
-                                            max_rectangle_texture_size,
-                                            max_3d_texture_size,
-                                            max_array_texture_layers,
-                                            bind_generates_resource_));
+  texture_manager_.reset(new TextureManager(
+      memory_tracker_.get(), feature_info_.get(), max_texture_size,
+      max_cube_map_texture_size, max_rectangle_texture_size,
+      max_3d_texture_size, max_array_texture_layers, bind_generates_resource_,
+      progress_reporter_));
   texture_manager_->set_framebuffer_manager(framebuffer_manager_.get());
 
   const GLint kMinTextureImageUnits = 8;
   const GLint kMinVertexTextureImageUnits = 0;
   if (!QueryGLFeatureU(GL_MAX_TEXTURE_IMAGE_UNITS, kMinTextureImageUnits,
                        &max_texture_image_units_)) {
     DLOG(ERROR) << "ContextGroup::Initialize failed because too few "
                 << "texture image units supported ("
                 << max_texture_image_units_
                 << ", should be " << kMinTextureImageUnits << ").";
@@ skipping 108 matching lines @@
       DLOG(ERROR) << "ContextGroup::Initialize failed because maximum "
                   << "cube texture size is too small ("
                   << max_cube_map_texture_size << ", should be "
                   << kES3MinCubeMapSize << ").";
       return false;
     }
   }
 
   path_manager_.reset(new PathManager());
 
-  program_manager_.reset(
-      new ProgramManager(program_cache_,
-                         max_varying_vectors_,
-                         max_draw_buffers_,
-                         max_dual_source_draw_buffers_,
-                         max_vertex_attribs_,
-                         gpu_preferences_,
-                         feature_info_.get()));
+  program_manager_.reset(new ProgramManager(
+      program_cache_, max_varying_vectors_, max_draw_buffers_,
+      max_dual_source_draw_buffers_, max_vertex_attribs_, gpu_preferences_,
+      feature_info_.get(), progress_reporter_));
 
   if (!texture_manager_->Initialize()) {
     DLOG(ERROR) << "Context::Group::Initialize failed because texture manager "
                 << "failed to initialize.";
     return false;
   }
 
   decoders_.push_back(base::AsWeakPtr<GLES2Decoder>(decoder));
   return true;
 }
@@ skipping 18 matching lines @@
 };
 
 }  // namespace anonymous
 
 bool ContextGroup::HaveContexts() {
   decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(), IsNull),
                   decoders_.end());
   return !decoders_.empty();
 }
 
+void ContextGroup::ReportProgress() {
+  if (progress_reporter_)
+    progress_reporter_->ReportProgress();
+}
+
 void ContextGroup::Destroy(GLES2Decoder* decoder, bool have_context) {
   decoders_.erase(std::remove_if(decoders_.begin(), decoders_.end(),
                                  WeakPtrEquals<gles2::GLES2Decoder>(decoder)),
                   decoders_.end());
   // If we still have contexts do nothing.
   if (HaveContexts()) {
     return;
   }
 
   if (buffer_manager_ != nullptr) {
     if (!have_context) {
       buffer_manager_->MarkContextLost();
     }
     buffer_manager_->Destroy();
     buffer_manager_.reset();
+    ReportProgress();
   }
 
   if (framebuffer_manager_ != NULL) {
     framebuffer_manager_->Destroy(have_context);
     if (texture_manager_)
       texture_manager_->set_framebuffer_manager(NULL);
     framebuffer_manager_.reset();
+    ReportProgress();
   }
 
   if (renderbuffer_manager_ != NULL) {
     renderbuffer_manager_->Destroy(have_context);
     renderbuffer_manager_.reset();
+    ReportProgress();
   }
 
   if (texture_manager_ != NULL) {
     texture_manager_->Destroy(have_context);
     texture_manager_.reset();
+    ReportProgress();
   }
 
   if (path_manager_ != NULL) {
     path_manager_->Destroy(have_context);
     path_manager_.reset();
+    ReportProgress();
   }
 
   if (program_manager_ != NULL) {
     program_manager_->Destroy(have_context);
     program_manager_.reset();
+    ReportProgress();
   }
 
   if (shader_manager_ != NULL) {
     shader_manager_->Destroy(have_context);
     shader_manager_.reset();
+    ReportProgress();
   }
 
   if (sampler_manager_ != NULL) {
     sampler_manager_->Destroy(have_context);
     sampler_manager_.reset();
+    ReportProgress();
   }
 
   memory_tracker_ = NULL;
 
   passthrough_resources_->Destroy(have_context);
   passthrough_resources_.reset();
+  ReportProgress();

[danakj, 2016/10/06 21:49:54]

nit: This one seems unneeded, when you're leaving the function the next task
will run right away?

You've placed them at the end of each step but really conceptually they are
before each step to say "I did things and I might sleep for a while now but dont
worry"

[danakj, 2016/10/06 21:51:01]

Or maybe it's worth keeping to chain with other functions cuz you're putting
them after work in each case actually so ignore me.

 }
 
 uint32_t ContextGroup::GetMemRepresented() const {
   uint32_t total = 0;
   if (buffer_manager_.get())
     total += buffer_manager_->mem_represented();
   if (renderbuffer_manager_.get())
     total += renderbuffer_manager_->mem_represented();
   if (texture_manager_.get())
     total += texture_manager_->mem_represented();
@@ skipping 55 matching lines @@
     GLuint client_id, GLuint* service_id) const {
   Buffer* buffer = buffer_manager_->GetBuffer(client_id);
   if (!buffer)
     return false;
   *service_id = buffer->service_id();
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu