Revert 260177 "By keeping track of transfer buffer usage (both s..."

trunk/src/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,
-    AsyncPixelTransferDelegate* delegate,
-    const base::Closure& task)
+    uint64 transfer_id, 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