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 379 matching lines @@
 }
 
 GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
     : host_id_(host_id),
       valid_(true),
       in_process_(false),
       swiftshader_rendering_(false),
       kind_(kind),
       process_launched_(false),
       initialized_(false),
+      expecting_shutdown_(false),
       gpu_crash_recorded_(false),
       uma_memory_stats_received_(false) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSingleProcess) ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kInProcessGPU)) {
     in_process_ = true;
   }
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
@@ skipping 486 matching lines @@
 #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());
+  expecting_shutdown_ = true;
+}
+
 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 107 matching lines @@
     GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
         *iter, GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
   }
 }
 
 void GpuProcessHost::RecordProcessCrash() {
   // Skip if a GPU process crash was already counted.
   if (gpu_crash_recorded_)
     return;
 
+  // Skip if GPU process was asked to stop and stopped successfully.
+  if (expecting_shutdown_) {
+    expecting_shutdown_ = false;
+    int exit_code;
+    base::TerminationStatus status =
+        process_->GetTerminationStatus(false, &exit_code);
+    if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION) {
+      gpu_crash_recorded_ = true;
+      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;
 
   bool disable_crash_limit = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableGpuProcessCrashLimit);
@@ skipping 96 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