Remove GPU relinquish resources infrastructure and stop GPU process.

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 "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/message_router.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
-#if defined(USE_OZONE)
-#include "ui/ozone/public/gpu_platform_support.h"
-#include "ui/ozone/public/ozone_platform.h"
-#endif
 
 namespace content {
 
 GpuChannelManager::GpuChannelManager(
     MessageRouter* router,
     GpuWatchdog* watchdog,
     base::SingleThreadTaskRunner* io_task_runner,
     base::WaitableEvent* shutdown_event,
     IPC::SyncChannel* channel,
     IPC::AttachmentBroker* broker,
     gpu::SyncPointManager* sync_point_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : io_task_runner_(io_task_runner),
       shutdown_event_(shutdown_event),
       router_(router),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(sync_point_manager),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
       channel_(channel),
-      relinquish_resources_pending_(false),
       attachment_broker_(broker),
       weak_factory_(this) {
   DCHECK(router_);
   DCHECK(io_task_runner);
   DCHECK(shutdown_event);
 }
 
 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 12 matching lines @@
 
 bool GpuChannelManager::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
-    IPC_MESSAGE_HANDLER(GpuMsg_RelinquishResources, OnRelinquishResources)
+    IPC_MESSAGE_HANDLER(GpuMsg_Finalize, OnFinalize)
     IPC_MESSAGE_HANDLER(GpuMsg_UpdateValueState, OnUpdateValueState)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) { return router_->Send(msg); }
 
 void GpuChannelManager::OnEstablishChannel(int client_id,
                                            bool share_context,
@@ skipping 34 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 79 matching lines @@
        iter != gpu_channels_.end(); ++iter) {
     iter->second->MarkAllContextsLost();
   }
   base::ThreadTaskRunnerHandle::Get()->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() {
-  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
-  }
-}
-
-void GpuChannelManager::OnResourcesRelinquished() {
-  Send(new GpuHostMsg_ResourcesRelinquished());
+void GpuChannelManager::OnFinalize() {
+  // Quit the GPU process
+  base::MessageLoop::current()->Quit();

[halliwell, 2015/07/25 17:00:38]

Question: are there any circumstances in which the process doesn't terminate
completely after this?  i.e. on the browser side, do we need to consider a
timeout and force stop?

 }
 
 }  // namespace content