Iterative cleanup for GL programs in GPU process

gpu/ipc/service/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 "gpu/ipc/service/gpu_channel_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 22 matching lines @@
 
 namespace {
 #if defined(OS_ANDROID)
 // Amount of time we expect the GPU to stay powered up without being used.
 const int kMaxGpuIdleTimeMs = 40;
 // Maximum amount of time we keep pinging the GPU waiting for the client to
 // draw.
 const int kMaxKeepAliveTimeMs = 200;
 #endif
 
+// The maximum amount of time we will spend deleting channels before yielding
+// to other tasks.
+const int kMaxChannelDeleterRuntimeS = 1;
 }
 
 GpuChannelManager::GpuChannelManager(
     const GpuPreferences& gpu_preferences,
     GpuChannelManagerDelegate* delegate,
     GpuWatchdogThread* watchdog,
     base::SingleThreadTaskRunner* task_runner,
     base::SingleThreadTaskRunner* io_task_runner,
     base::WaitableEvent* shutdown_event,
     SyncPointManager* sync_point_manager,
@@ skipping 53 matching lines @@
 }
 
 gles2::FramebufferCompletenessCache*
 GpuChannelManager::framebuffer_completeness_cache() {
   if (!framebuffer_completeness_cache_.get())
     framebuffer_completeness_cache_ =
         new gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_.get();
 }
 
+void GpuChannelManager::RunChannelDeleter() {
+  base::TimeTicks timeout =
+      base::TimeTicks::Now() +
+      base::TimeDelta::FromSeconds(kMaxChannelDeleterRuntimeS);
+
+  for (; pending_deleters_.size() > 0; pending_deleters_.pop()) {
+    if (!pending_deleters_.front()->DeleteWithTimeout(timeout)) {
+      // If DeleteWithTimeout returns false, the timeout was reached
+      // before deletion completed. We should not continue deleting.
+      break;
+    }
+  }
+
+  if (pending_deleters_.size() > 0) {
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&GpuChannelManager::RunChannelDeleter,
+                                      weak_factory_.GetWeakPtr()));
+  } else {
+    channel_deleter_running_ = false;
+  }
+}
+
 void GpuChannelManager::RemoveChannel(int client_id) {
   delegate_->DidDestroyChannel(client_id);
-  gpu_channels_.erase(client_id);
+  pending_deleters_.emplace(
+      new GpuChannelDeleter(gpu_channels_.take_and_erase(client_id)));
+  if (!channel_deleter_running_) {
+    channel_deleter_running_ = true;
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&GpuChannelManager::RunChannelDeleter,
+                                      weak_factory_.GetWeakPtr()));
+  }
 }
 
 GpuChannel* GpuChannelManager::LookupChannel(int32_t client_id) const {
   const auto& it = gpu_channels_.find(client_id);
   return it != gpu_channels_.end() ? it->second : nullptr;
 }
 
 std::unique_ptr<GpuChannel> GpuChannelManager::CreateGpuChannel(
     int client_id,
     uint64_t client_tracing_id,
@@ skipping 154 matching lines @@
     }
   }
   if (!stub || !stub->decoder()->MakeCurrent())
     return;
   glFinish();
   DidAccessGpu();
 }
 #endif
 
 }  // namespace gpu