GPU: Replace AsyncPixelTransferState with AsyncPixelTransferDelegate.

gpu/command_buffer/service/async_pixel_transfer_manager_sync.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_sync.h"
 
 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
 
 namespace gpu {
 
-namespace {
-
-class AsyncPixelTransferStateImpl : public AsyncPixelTransferState {
- public:
-  AsyncPixelTransferStateImpl() {}
-
-  // Implement AsyncPixelTransferState:
-  virtual bool TransferIsInProgress() OVERRIDE {
-    return false;
-  }
-
- private:
-  virtual ~AsyncPixelTransferStateImpl() {}
-};
-
-}  // namespace
-
 // Class which handles async pixel transfers synchronously.
 class AsyncPixelTransferDelegateSync : public AsyncPixelTransferDelegate {
  public:
   explicit AsyncPixelTransferDelegateSync(
       AsyncPixelTransferManagerSync::SharedState* shared_state);
   virtual ~AsyncPixelTransferDelegateSync();
 
   // Implement AsyncPixelTransferDelegate:
-  virtual AsyncPixelTransferState* CreatePixelTransferState(
-      GLuint texture_id,
-      const AsyncTexImage2DParams& define_params) OVERRIDE;
   virtual void AsyncTexImage2D(
-      AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params,
       const base::Closure& bind_callback) OVERRIDE;
   virtual void AsyncTexSubImage2D(
-      AsyncPixelTransferState* transfer_state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
-  virtual void WaitForTransferCompletion(
-      AsyncPixelTransferState* state) OVERRIDE;
+  virtual bool TransferIsInProgress() OVERRIDE;
+  virtual void WaitForTransferCompletion() OVERRIDE;
 
  private:
   // Safe to hold a raw pointer because SharedState is owned by the Manager
   // which owns the Delegate.
   AsyncPixelTransferManagerSync::SharedState* shared_state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateSync);
 };
 
 AsyncPixelTransferDelegateSync::AsyncPixelTransferDelegateSync(
     AsyncPixelTransferManagerSync::SharedState* shared_state)
     : shared_state_(shared_state) {}
 
 AsyncPixelTransferDelegateSync::~AsyncPixelTransferDelegateSync() {}
 
-AsyncPixelTransferState* AsyncPixelTransferDelegateSync::
-    CreatePixelTransferState(GLuint texture_id,
-                             const AsyncTexImage2DParams& define_params) {
-  return new AsyncPixelTransferStateImpl;
-}
-
 void AsyncPixelTransferDelegateSync::AsyncTexImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
   // Save the define params to return later during deferred
   // binding of the transfer texture.
-  DCHECK(transfer_state);
   void* data = GetAddress(mem_params);
   glTexImage2D(
       tex_params.target,
       tex_params.level,
       tex_params.internal_format,
       tex_params.width,
       tex_params.height,
       tex_params.border,
       tex_params.format,
       tex_params.type,
       data);
   // The texture is already fully bound so just call it now.
   bind_callback.Run();
 }
 
 void AsyncPixelTransferDelegateSync::AsyncTexSubImage2D(
-    AsyncPixelTransferState* transfer_state,
     const AsyncTexSubImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   void* data = GetAddress(mem_params);
-  DCHECK(transfer_state);
   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   glTexSubImage2D(
       tex_params.target,
       tex_params.level,
       tex_params.xoffset,
       tex_params.yoffset,
       tex_params.width,
       tex_params.height,
       tex_params.format,
       tex_params.type,
       data);
   shared_state_->texture_upload_count++;
   shared_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time;
 }
 
-void AsyncPixelTransferDelegateSync::WaitForTransferCompletion(
-    AsyncPixelTransferState* state) {
+bool AsyncPixelTransferDelegateSync::TransferIsInProgress() {
+  // Already done.
+  return false;
+}
+
+void AsyncPixelTransferDelegateSync::WaitForTransferCompletion() {
   // Already done.
 }
 
 AsyncPixelTransferManagerSync::SharedState::SharedState()
     : texture_upload_count(0) {}
 
 AsyncPixelTransferManagerSync::SharedState::~SharedState() {}
 
-AsyncPixelTransferManagerSync::AsyncPixelTransferManagerSync()
-    : delegate_(new AsyncPixelTransferDelegateSync(&shared_state_)) {}
+AsyncPixelTransferManagerSync::AsyncPixelTransferManagerSync() {}
 
 AsyncPixelTransferManagerSync::~AsyncPixelTransferManagerSync() {}
 
 void AsyncPixelTransferManagerSync::BindCompletedAsyncTransfers() {
   // Everything is already bound.
 }
 
 void AsyncPixelTransferManagerSync::AsyncNotifyCompletion(
     const AsyncMemoryParams& mem_params,
     const CompletionCallback& callback) {
   callback.Run(mem_params);
 }
 
 uint32 AsyncPixelTransferManagerSync::GetTextureUploadCount() {
   return shared_state_.texture_upload_count;
 }
 
 base::TimeDelta AsyncPixelTransferManagerSync::GetTotalTextureUploadTime() {
   return shared_state_.total_texture_upload_time;
 }
 
 void AsyncPixelTransferManagerSync::ProcessMorePendingTransfers() {
 }
 
 bool AsyncPixelTransferManagerSync::NeedsProcessMorePendingTransfers() {
   return false;
 }
 
 AsyncPixelTransferDelegate*
-AsyncPixelTransferManagerSync::GetAsyncPixelTransferDelegate() {
-  return delegate_.get();
+AsyncPixelTransferManagerSync::CreatePixelTransferDelegateImpl(
+    gles2::TextureRef* ref,
+    const AsyncTexImage2DParams& define_params) {
+  return new AsyncPixelTransferDelegateSync(&shared_state_);
 }
 
 }  // namespace gpu
-