gpu: Implement idle async pixel transfers.

ui/gl/async_pixel_transfer_delegate_stub.h

 // 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.
 
 #ifndef UI_GL_ASYNC_TASK_DELEGATE_STUB_H_
 #define UI_GL_ASYNC_TASK_DELEGATE_STUB_H_
 
+#include <list>
+#include <queue>
+
+#include "base/callback.h"
 #include "ui/gl/async_pixel_transfer_delegate.h"
 
 namespace gfx {
-
-class AsyncTransferStateStub : public AsyncPixelTransferState {
- public:
-  // implement AsyncPixelTransferState:
-  virtual bool TransferIsInProgress() OVERRIDE;
-  virtual void BindTransfer(AsyncTexImage2DParams* bound_params) OVERRIDE;
-
- private:
-  friend class AsyncPixelTransferDelegateStub;
-  bool needs_late_bind_;
-  AsyncTexImage2DParams late_bind_define_params_ ;
-
-  explicit AsyncTransferStateStub(GLuint texture_id);
-  virtual ~AsyncTransferStateStub();
-  DISALLOW_COPY_AND_ASSIGN(AsyncTransferStateStub);
-};
+class GLSurface;
+class TransferStateInternalStub;
+class ScopedSafeSharedMemory;
 
 // Class which handles async pixel transfers (as a fallback).
 // This class just does the uploads synchronously.

[Sami, 2013/03/07 16:57:19]

Please update this comment. Maybe the class could be renamed too since it's not
a simple stub any longer -- up to you.

[reveman, 2013/03/07 20:21:04]

Updated the comment.

I think there's some cleanup to be done in terms of naming and structure of the
AsyncPixelTransferDelegate in general. This was never really a stub class. I
think we might want to structure this more like GLSurface but would prefer to do
that as a follow up with Eric's input.

-class AsyncPixelTransferDelegateStub : public AsyncPixelTransferDelegate {
+class AsyncPixelTransferDelegateStub : public AsyncPixelTransferDelegate,
+    public base::SupportsWeakPtr<AsyncPixelTransferDelegateStub> {
  public:
   static scoped_ptr<AsyncPixelTransferDelegate>
       Create(gfx::GLContext* context);
 
   AsyncPixelTransferDelegateStub();
   virtual ~AsyncPixelTransferDelegateStub();
 
   // implement AsyncPixelTransferDelegate:
   virtual void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       const CompletionCallback& callback) OVERRIDE;
   virtual void AsyncTexImage2D(
       AsyncPixelTransferState* transfer_state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void AsyncTexSubImage2D(
       AsyncPixelTransferState* transfer_state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void WaitForTransferCompletion(
-      AsyncPixelTransferState* state) OVERRIDE;
+      AsyncPixelTransferState* transfer_state) OVERRIDE;
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
+  virtual void ProcessPendingTransfers() OVERRIDE;
+  virtual bool HasPendingTransfers() OVERRIDE;
+
  private:
+  struct Transfer {
+    Transfer(TransferStateInternalStub* state, const base::Closure& task);
+    ~Transfer();
+
+    scoped_refptr<TransferStateInternalStub> state;
+    base::Closure task;
+    std::queue<base::Closure> notifications;
+  };
+
   // implement AsyncPixelTransferDelegate:
   virtual AsyncPixelTransferState*
       CreateRawPixelTransferState(GLuint texture_id) OVERRIDE;
 
+  void PerformNotifyCompletion(
+      AsyncMemoryParams mem_params,
+      ScopedSafeSharedMemory* safe_shared_memory,
+      const CompletionCallback& callback);
+  void PerformAsyncTexImage2D(
+      scoped_refptr<TransferStateInternalStub> state,
+      AsyncTexImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      ScopedSafeSharedMemory* safe_shared_memory);
+  void PerformAsyncTexSubImage2D(
+      scoped_refptr<TransferStateInternalStub> state,
+      AsyncTexSubImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      ScopedSafeSharedMemory* safe_shared_memory);
+
   int texture_upload_count_;
   base::TimeDelta total_texture_upload_time_;
 
+  std::list<Transfer> transfers_;
+
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateStub);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GL_ASYNC_TASK_DELEGATE_ANDROID_H_