gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc

 // Copyright 2013 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/command_buffer/service/async_pixel_transfer_manager_idle.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/lazy_instance.h"
@@ skipping 89 matching lines @@
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
+      this,
       base::Bind(
           &AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D,
           AsWeakPtr(),
           tex_params,
           mem_params,
           bind_callback,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)))));
 
   transfer_in_progress_ = true;
 }
 
 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D(
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
+      this,
       base::Bind(
           &AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
           AsWeakPtr(),
           tex_params,
           mem_params,
           base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                  mem_params.shared_memory,
                                                  mem_params.shm_size)))));
 
   transfer_in_progress_ = true;
@@ skipping 104 matching lines @@
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
   transfer_in_progress_ = false;
   shared_state_->texture_upload_count++;
   shared_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time;
 }
 
 AsyncPixelTransferManagerIdle::Task::Task(
-    uint64 transfer_id, const base::Closure& task)
+    uint64 transfer_id,
+    AsyncPixelTransferDelegate* delegate,
+    const base::Closure& task)
     : transfer_id(transfer_id),
+      delegate(delegate),
       task(task) {
 }
 
 AsyncPixelTransferManagerIdle::Task::~Task() {}
 
 AsyncPixelTransferManagerIdle::SharedState::SharedState()
     : texture_upload_count(0) {}
 
 AsyncPixelTransferManagerIdle::SharedState::~SharedState() {}
 
@@ skipping 21 matching lines @@
 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion(
     const AsyncMemoryParams& mem_params,
     AsyncPixelTransferCompletionObserver* observer) {
   if (shared_state_.tasks.empty()) {
     observer->DidComplete(mem_params);
     return;
   }
 
   shared_state_.tasks.push_back(
       Task(0,  // 0 transfer_id for notification tasks.
-           base::Bind(
-               &PerformNotifyCompletion,
-               mem_params,
-               base::Owned(new ScopedSafeSharedMemory(safe_shared_memory_pool(),
-                                                      mem_params.shared_memory,
-                                                      mem_params.shm_size)),
-               make_scoped_refptr(observer))));
+           NULL,
+           base::Bind(&PerformNotifyCompletion,
+                      mem_params,
+                      base::Owned(
+                          new ScopedSafeSharedMemory(safe_shared_memory_pool(),
+                                                     mem_params.shared_memory,
+                                                     mem_params.shm_size)),
+                      make_scoped_refptr(observer))));
 }
 
 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() {
   return shared_state_.texture_upload_count;
 }
 
 base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() {
   return shared_state_.total_texture_upload_time;
 }
 
 void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() {
   if (shared_state_.tasks.empty())
     return;
 
   // First task should always be a pixel transfer task.
   DCHECK(shared_state_.tasks.front().transfer_id);
   shared_state_.tasks.front().task.Run();
   shared_state_.tasks.pop_front();
 
   shared_state_.ProcessNotificationTasks();
 }
 
 bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() {
   return !shared_state_.tasks.empty();
 }
 
+void AsyncPixelTransferManagerIdle::WaitAllAsyncTexImage2D() {
+  if (shared_state_.tasks.empty())
+    return;
+
+  const Task& task = shared_state_.tasks.back();
+  if (task.delegate)
+    task.delegate->WaitForTransferCompletion();
+}
+
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateIdle(&shared_state_,
                                             ref->service_id(),
                                             define_params);
 }
 
 }  // namespace gpu