Remove GPU relinquish resources infrastructure and stop GPU process.

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include "base/base64.h"
 #include "base/base_switches.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 312 matching lines @@
   host_id = ++last_host_id;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause",
                             cause,
                             CAUSE_FOR_GPU_LAUNCH_MAX_ENUM);
 
   GpuProcessHost* host = new GpuProcessHost(host_id, kind);
   if (host->Init())
     return host;
 
+  // TODO(sievers): Revisit this behavior. It's not really a crash, but we also
+  // want the fallback-to-sw behavior if we cannot initialize the GPU.
+  RecordProcessCrash()
+
   delete host;
   return NULL;
 }
 
 // static
 void GpuProcessHost::GetProcessHandles(
     const GpuDataManager::GetGpuProcessHandlesCallback& callback)  {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
@@ skipping 80 matching lines @@
       base::Bind(base::IgnoreResult(&GpuProcessHostUIShim::Create), host_id));
 
   process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_GPU, this));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
 
   SendOutstandingReplies();
 
-  RecordProcessCrash();
-
   // In case we never started, clean up.
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   if (!io_surface_manager_token_.IsZero()) {
     BrowserIOSurfaceManager::GetInstance()->InvalidateGpuProcessToken();
     io_surface_manager_token_.SetZero();
@@ skipping 424 matching lines @@
     const IPC::Message& message) {
   RenderWidgetResizeHelper::Get()->PostGpuProcessMsg(host_id_, message);
 }
 #endif
 
 void GpuProcessHost::OnProcessLaunched() {
   UMA_HISTOGRAM_TIMES("GPU.GPUProcessLaunchTime",
                       base::TimeTicks::Now() - init_start_time_);
 }
 
+void GpuProcessHost::OnProcessLaunchFailed() {
+  RecordProcessCrash();
+}
+
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
   RecordProcessCrash();
   GpuDataManagerImpl::GetInstance()->ProcessCrashed(
       process_->GetTerminationStatus(true /* known_dead */, NULL));
 }
 
 GpuProcessHost::GpuProcessKind GpuProcessHost::kind() {
   return kind_;
 }
 
 void GpuProcessHost::ForceShutdown() {
   // This is only called on the IO thread so no race against the constructor
   // for another GpuProcessHost.
   if (g_gpu_process_hosts[kind_] == this)
     g_gpu_process_hosts[kind_] = NULL;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   if (!io_surface_manager_token_.IsZero()) {
     BrowserIOSurfaceManager::GetInstance()->InvalidateGpuProcessToken();
     io_surface_manager_token_.SetZero();
   }
 #endif
 
   process_->ForceShutdown();
 }
 
+void GpuProcessHost::StopGpuProcess() {
+  Send(new GpuMsg_Finalize());
+}
+
 void GpuProcessHost::BeginFrameSubscription(
     int surface_id,
     base::WeakPtr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   frame_subscribers_[surface_id] = subscriber;
 }
 
 void GpuProcessHost::EndFrameSubscription(int surface_id) {
   frame_subscribers_.erase(surface_id);
 }
 
@@ skipping 104 matching lines @@
   for (std::multiset<GURL>::iterator iter =
            urls_with_live_offscreen_contexts_.begin();
        iter != urls_with_live_offscreen_contexts_.end(); ++iter) {
     GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
         *iter, GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
   }
 }
 
 void GpuProcessHost::RecordProcessCrash() {
   // Skip if a GPU process crash was already counted.
   if (gpu_crash_recorded_)

[no sievers, 2015/07/29 19:05:19]

You can remove this boolean also now, as with your changes it should only be
called once.

     return;
 
   // Maximum number of times the GPU process is allowed to crash in a session.
   // Once this limit is reached, any request to launch the GPU process will
   // fail.
   const int kGpuMaxCrashCount = 3;
 
   // Last time the GPU process crashed.
   static base::Time last_gpu_crash_time;
 
@@ skipping 98 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content