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 71 matching lines @@
 
 void AsyncPixelTransferDelegateIdle::AsyncTexImage2D(
     const AsyncTexImage2DParams& tex_params,
     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);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
+      this,
       base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D,
                  AsWeakPtr(),
                  tex_params,
                  mem_params,
                  bind_callback)));
 
   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);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
       id_,
+      this,
       base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
                  AsWeakPtr(),
                  tex_params,
                  mem_params)));
 
   transfer_in_progress_ = true;
 }
 
 bool  AsyncPixelTransferDelegateIdle::TransferIsInProgress() {
   return transfer_in_progress_;
@@ skipping 98 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.
+           NULL,
            base::Bind(
                &PerformNotifyCompletion,
                mem_params,
                make_scoped_refptr(observer))));
 }
 
 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() {
   return shared_state_.texture_upload_count;
 }
 
@@ skipping 10 matching lines @@
   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