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) {

[dcheng, 2015/07/28 18:47:21]

Why does this set gpu_crash_recorded_ to true if it terminated "normally"?

[derekjchow1, 2015/07/28 18:57:28]

RecordProcessCrash can be called multiple times for one GPU crash. When
gpu_crash_recorded_ is true, RecordProcessCrash is noop (so no extra crashes are
recorded). 

When stopping the GPU process, RecordProcessCrash can be called multiple times
as well. The first call checks the termination status, and the subsequent calls
are no-op.

Perhaps I should rename gpu_crash_recorded_ to gpu_crash_handled_? Would that be
more clear?

[dcheng, 2015/07/28 19:04:27]

Huh. That's kind of non-intuitive (both the fact that this can be called
multiple times for one crash, and the meaning of the field).

It'd be nice to clean this up, though it could be in a separate patch.

[no sievers, 2015/07/28 19:21:20]

Actually it's not quite obvious how you get here.
OnProcessCrashed() should only happen for abnormal termination (see
browser_child_process_host_impl.cc). Can we maybe handle this normal shutdown
more explicitly instead of routing it through RecordProcessCrash() to then just
early out?

[derekjchow1, 2015/07/28 21:01:44]

Sure. The only other place RecordProcessCrash is called is in the destructor of
this class. This CL now preforms the check there. PTAL.

+      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