Ping watchdog thread during GpuChannel destruction

gpu/ipc/service/gpu_command_buffer_stub.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/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.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/query_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_memory_manager.h"
 #include "gpu/ipc/service/gpu_memory_tracking.h"
@@ skipping 59 matching lines @@
  private:
   ~GpuCommandBufferMemoryTracker() override {}
   std::unique_ptr<GpuMemoryTrackingGroup> tracking_group_;
   const uint64_t client_tracing_id_;
   const int client_id_;
   const uint64_t share_group_tracing_guid_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferMemoryTracker);
 };
 
+// GpuCommandBufferProgressReporter is used as a bridge between the
+// ContextGroup and the GpuChannel's GpuWatchdogThread.
+class GpuCommandBufferProgressReporter : public gles2::ProgressReporter {
+ public:
+  GpuCommandBufferProgressReporter(GpuChannel* channel) : channel_(channel) {}
+
+  void ReportProgress() override {
+    if (auto* watchdog = channel_->watchdog()) {
+      // CheckArmed posts a task. Throttle this so we don't post more than

[vmiura, 2016/09/30 18:24:35]

Rather than adding throttling here, it seems we could make
GpuWatchdogThread::PostAcknowledge() keep track if it posted a task
(acknowledged_ flag) so that it doesn't post OnAcknowledge repeatedly.

The flag would be cleared when the check was re-armed.

OnAcknowledge() earlies out anyway if the check isn't armed so I don't know why
we didn't just do this.

[ericrk, 2016/10/01 06:19:27]

Good point - I don't want to overload this CL, so I've removed the throttling
here and am adding the GpuWatchdogThread tweaks in a new CL.

+      // one task per second.
+      base::TimeTicks now = base::TimeTicks::Now();
+      if (now < next_check_time_)
+        return;
+
+      next_check_time_ = now + base::TimeDelta::FromSeconds(kMaxCheckRateS);
+      watchdog->CheckArmed();
+    }
+  }
+
+ private:
+  // The max rate at which we will signal the watchdog thread.
+  static const int kMaxCheckRateS = 1;
+
+  // The GpuChannel always outlives the GpuCommandBufferStub and the
+  // ContextGroups it creates, so it's safe to hold by raw pointer here.
+  GpuChannel* channel_;
+  base::TimeTicks next_check_time_;
+};
+
 // FastSetActiveURL will shortcut the expensive call to SetActiveURL when the
 // url_hash matches.
 void FastSetActiveURL(const GURL& url, size_t url_hash, GpuChannel* channel) {
   // Leave the previously set URL in the empty case -- empty URLs are given by
   // BlinkPlatformImpl::createOffscreenGraphicsContext3DProvider. Hopefully the
   // onscreen context URL was set previously and will show up even when a crash
   // occurs during offscreen command processing.
   if (url.is_empty())
     return;
   static size_t g_last_url_hash = 0;
@@ skipping 344 matching lines @@
         new gles2::FeatureInfo(manager->gpu_driver_bug_workarounds());
     gpu::GpuMemoryBufferFactory* gmb_factory =
         channel_->gpu_channel_manager()->gpu_memory_buffer_factory();
     context_group_ = new gles2::ContextGroup(
         manager->gpu_preferences(), channel_->mailbox_manager(),
         new GpuCommandBufferMemoryTracker(channel_,
                                           command_buffer_id_.GetUnsafeValue()),
         manager->shader_translator_cache(),
         manager->framebuffer_completeness_cache(), feature_info,
         init_params.attribs.bind_generates_resource,
-        gmb_factory ? gmb_factory->AsImageFactory() : nullptr);
+        gmb_factory ? gmb_factory->AsImageFactory() : nullptr,
+        base::MakeUnique<GpuCommandBufferProgressReporter>(channel_));
   }
 
 #if defined(OS_MACOSX)
   // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
   // performance regressions when enabling FCM.
   // http://crbug.com/180463
   if (init_params.attribs.gpu_preference == gl::PreferIntegratedGpu)
     use_virtualized_gl_context_ = true;
 #endif
 
@@ skipping 630 matching lines @@
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, params));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace gpu