Free worker context resources on idle.

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 105 matching lines @@
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/scheduler/resource_dispatch_throttler.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/service_worker/service_worker_context_client.h"
 #include "content/renderer/service_worker/service_worker_context_message_filter.h"
 #include "content/renderer/shared_worker/embedded_shared_worker_stub.h"
 #include "gin/public/debug.h"
 #include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/base/media.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
@@ skipping 17 matching lines @@
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScriptController.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 #include "third_party/skia/include/core/SkGraphics.h"
+#include "third_party/skia/include/gpu/GrContext.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(OS_ANDROID)
 #include <cpu-features.h>
 #include "content/renderer/android/synchronous_compositor_filter.h"
 #include "content/renderer/android/synchronous_compositor_output_surface.h"
 #include "content/renderer/media/android/renderer_demuxer_android.h"
 #include "content/renderer/media/android/stream_texture_factory.h"
 #include "media/base/android/media_codec_util.h"
@@ skipping 260 matching lines @@
       gpu::kNullSurfaceHandle,
       GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext"),
       automatic_flushes, support_locking, limits, attributes, nullptr, type));
 }
 
 bool IsRunningInMash() {
   const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
   return cmdline->HasSwitch(switches::kIsRunningInMash);
 }
 
+void OnSharedWorkerContextIdle(cc::ContextProvider* context_provider) {
+  // If we can't acquire the lock, someone has started using this context, so
+  // we are no longer idle.
+  base::Lock* lock = context_provider->GetLock();
+  if (!lock->Try())
+    return;
+
+  context_provider->DetachFromThread();
+  context_provider->BindToCurrentThread();
+
+  context_provider->DeleteCachedResources();
+  context_provider->ContextSupport()->TrimResources();

[danakj, 2016/08/23 01:26:24]

Why do we need a separate TrimResources from DeleteCachedResources?

+
+  // Detach from thread to allow a new thread to attach.
+  context_provider->DetachFromThread();
+  lock->Release();
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   ~MemoryObserver() override {}
 
   void WillProcessTask(const base::PendingTask& pending_task) override {}
 
@@ skipping 1666 matching lines @@
     stream_priority = gpu::GpuStreamPriority::LOW;
   }
 
   bool support_locking = true;
   shared_worker_context_provider_ = CreateOffscreenContext(
       std::move(gpu_channel_host), gpu::SharedMemoryLimits(), support_locking,
       command_buffer_metrics::RENDER_WORKER_CONTEXT, stream_id,
       stream_priority);
   if (!shared_worker_context_provider_->BindToCurrentThread())
     shared_worker_context_provider_ = nullptr;
+
+  // Set the idle callback. This callback is only called if ContextSupport
+  // is alive, so we know that the unreatained worker context provider

[danakj, 2016/08/23 01:26:24]

unretained

+  // pointer will also be alive.
+  shared_worker_context_provider_->ContextSupport()->SetIdleCallback(
+      base::Bind(&OnSharedWorkerContextIdle,
+                 base::Unretained(shared_worker_context_provider_.get())),
+      base::ThreadTaskRunnerHandle::Get());

[danakj, 2016/08/23 01:26:24]

what about just making it use the task runner the context is bound to? thats how
the callbacks on ContextProvider work

[ericrk, 2016/08/24 18:32:21]

The current callback systems always funnels through the Context/GpuControl.
Depending on the implementation, the Context/GpuControl may not have a task
runner (and may run callbacks directly), although typically it does have one.

It seems like we could:
- expose the task runner on GpuControl, and allow it to return null.
- Add a "ScheduleTask" and "ScheduleDelayedTask" to GpuControl, but at that
point we might as well just return the task runner?
- Move the idle callback to GpuControl/Context, although this would require some
new logic in each implementation of GpuControl/Context (similar to our other
callbacks I guess?)

   return shared_worker_context_provider_;
 }
 
 void RenderThreadImpl::SampleGamepads(blink::WebGamepads* data) {
   blink_platform_impl_->sampleGamepads(*data);
 }
 
 bool RenderThreadImpl::RendererIsHidden() const {
   return widget_count_ > 0 && hidden_widget_count_ == widget_count_;
 }
@@ skipping 92 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content