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.
+  host->RecordProcessCrash();
+
   delete host;
   return NULL;
 }
 
 // static
 void GpuProcessHost::GetProcessHandles(
     const GpuDataManager::GetGpuProcessHandlesCallback& callback)  {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
@@ skipping 47 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),
-      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
   // it for 'gpu thread' mode and only create one instance of host and thread.
@@ skipping 12 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 103 matching lines @@
 void GpuProcessHost::BlockLiveOffscreenContexts() {
   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_)
-    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);
 
   // Ending only acts as a failure if the GPU process was actually started and
   // was intended for actual rendering (and not just checking caps or other
   // options).
   if (process_launched_ && kind_ == GPU_PROCESS_KIND_SANDBOXED) {
-    gpu_crash_recorded_ = true;
     if (swiftshader_rendering_) {
       UMA_HISTOGRAM_ENUMERATION("GPU.SwiftShaderLifetimeEvents",
                                 DIED_FIRST_TIME + swiftshader_crash_count_,
                                 GPU_PROCESS_LIFETIME_EVENT_MAX);
 
       if (++swiftshader_crash_count_ >= kGpuMaxCrashCount &&
           !disable_crash_limit) {
         // SwiftShader is too unstable to use. Disable it for current session.
         gpu_enabled_ = false;
       }
@@ skipping 80 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