Release GPU resources only after renderer GPU channels are closed.

content/common/gpu/gpu_channel_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 "content/common/gpu/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
@@ skipping 83 matching lines @@
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(new gpu::SyncPointManager),
       gpu_memory_buffer_factory_(
           GpuMemoryBufferFactory::Create(GetGpuMemoryBufferFactoryType())),
       channel_(channel),
       filter_(
           new GpuChannelManagerMessageFilter(gpu_memory_buffer_factory_.get())),
+      relinquish_resources_pending_(false),
       weak_factory_(this) {
   DCHECK(router_);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
   channel_->AddFilter(filter_.get());
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
@@ skipping 16 matching lines @@
 gpu::gles2::ShaderTranslatorCache*
 GpuChannelManager::shader_translator_cache() {
   if (!shader_translator_cache_.get())
     shader_translator_cache_ = new gpu::gles2::ShaderTranslatorCache;
   return shader_translator_cache_.get();
 }
 
 void GpuChannelManager::RemoveChannel(int client_id) {
   Send(new GpuHostMsg_DestroyChannel(client_id));
   gpu_channels_.erase(client_id);
+  CheckRelinquishGpuResources();
 }
 
 int GpuChannelManager::GenerateRouteID() {
   static int last_id = 0;
   return ++last_id;
 }
 
 void GpuChannelManager::AddRoute(int32 routing_id, IPC::Listener* listener) {
   router_->AddRoute(routing_id, listener);
 }
@@ skipping 67 matching lines @@
 
   Send(new GpuHostMsg_ChannelEstablished(channel_handle));
 }
 
 void GpuChannelManager::OnCloseChannel(
     const IPC::ChannelHandle& channel_handle) {
   for (GpuChannelMap::iterator iter = gpu_channels_.begin();
        iter != gpu_channels_.end(); ++iter) {
     if (iter->second->GetChannelName() == channel_handle.name) {
       gpu_channels_.erase(iter);
+      CheckRelinquishGpuResources();
       return;
     }
   }
 }
 
 void GpuChannelManager::OnCreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     int32 client_id,
     const GPUCreateCommandBufferConfig& init_params,
@@ skipping 83 matching lines @@
     iter->second->MarkAllContextsLost();
   }
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannelManager::OnLoseAllContexts,
                  weak_factory_.GetWeakPtr()));
 }
 
 void GpuChannelManager::OnLoseAllContexts() {
   gpu_channels_.clear();
+  CheckRelinquishGpuResources();
 }
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
 void GpuChannelManager::OnRelinquishResources() {
-  if (default_offscreen_surface_.get()) {
-    default_offscreen_surface_->DestroyAndTerminateDisplay();
-    default_offscreen_surface_ = nullptr;
+  relinquish_resources_pending_ = true;
+  CheckRelinquishGpuResources();
+}
+
+void GpuChannelManager::CheckRelinquishGpuResources() {
+  if (relinquish_resources_pending_ && gpu_channels_.size() <= 1) {
+    relinquish_resources_pending_ = false;
+    if (default_offscreen_surface_.get()) {
+      default_offscreen_surface_->DestroyAndTerminateDisplay();
+      default_offscreen_surface_ = NULL;
+    }
+#if defined(USE_OZONE)
+    ui::OzonePlatform::GetInstance()
+        ->GetGpuPlatformSupport()
+        ->RelinquishGpuResources(
+            base::Bind(&GpuChannelManager::OnResourcesRelinquished,
+                       weak_factory_.GetWeakPtr()));
+#else
+    OnResourcesRelinquished();
+#endif
   }
-#if defined(USE_OZONE)
-  ui::OzonePlatform::GetInstance()
-      ->GetGpuPlatformSupport()
-      ->RelinquishGpuResources(
-          base::Bind(&GpuChannelManager::OnResourcesRelinquished,
-                     weak_factory_.GetWeakPtr()));
-#else
-  OnResourcesRelinquished();
-#endif
 }
 
 void GpuChannelManager::OnResourcesRelinquished() {
   Send(new GpuHostMsg_ResourcesRelinquished());
 }
 
 }  // namespace content