gpu: Implement idle async pixel transfers.

ui/gl/async_pixel_transfer_delegate_android.cc

 // 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.
 
 #include "ui/gl/async_pixel_transfer_delegate_android.h"
 
 #include <list>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 95 matching lines @@
 void DoFullTexSubImage2D(const AsyncTexImage2DParams& tex_params, void* data) {
   glTexSubImage2D(
       GL_TEXTURE_2D, tex_params.level,
       0, 0, tex_params.width, tex_params.height,
       tex_params.format, tex_params.type, data);
 }
 
 // Gets the address of the data from shared memory.
 void* GetAddress(SharedMemory* shared_memory, uint32 shm_data_offset) {
   // Memory bounds have already been validated, so there
-  // is just DCHECKS here.
+  // are just DCHECKS here.
   CHECK(shared_memory);
   CHECK(shared_memory->memory());
   return static_cast<int8*>(shared_memory->memory()) + shm_data_offset;
 }
 
 class TransferThread : public base::Thread {
  public:
   TransferThread() : base::Thread(kAsyncTransferThreadName) {
     Start();
   }
@@ skipping 78 matching lines @@
 
   void BindTransfer() {
     TRACE_EVENT2("gpu", "BindAsyncTransfer glEGLImageTargetTexture2DOES",
                  "width", define_params_.width,
                  "height", define_params_.height);
     DCHECK(texture_id_);
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
 
     // We can only change the active texture and unit 0,
     // as that is all that will be restored.
-    glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture_id_);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image_);
     bind_callback_.Run();
 
     DCHECK(CHECK_GL());
   }
 
   void CreateEglImage(GLuint texture_id) {
     TRACE_EVENT0("gpu", "eglCreateImageKHR");
     DCHECK(texture_id);
@@ skipping 151 matching lines @@
       const AsyncMemoryParams& mem_params,
       const base::Closure& bind_callback) OVERRIDE;
   virtual void AsyncTexSubImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void WaitForTransferCompletion(
       AsyncPixelTransferState* state) OVERRIDE;
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
+  virtual bool ProcessMorePendingTransfers() OVERRIDE;
+  virtual bool NeedsProcessMorePendingTransfers() OVERRIDE;
 
  private:
   // implement AsyncPixelTransferDelegate:
   virtual AsyncPixelTransferState*
       CreateRawPixelTransferState(GLuint texture_id,
           const AsyncTexImage2DParams& define_params) OVERRIDE;
 
   static void PerformNotifyCompletion(
       AsyncMemoryParams mem_params,
       ScopedSafeSharedMemory* safe_shared_memory,
@@ skipping 79 matching lines @@
   // creation on the main thread as a work-around.
   bool wait_for_creation = is_qualcomm_;
 
   // Qualcomm has a race when using image_preserved=FALSE,
   // which can result in black textures even after the first upload.
   // Since using FALSE is mainly for performance (to avoid layout changes),
   // but Qualcomm itself doesn't seem to get any performance benefit,
   // we just using image_preservedd=TRUE on Qualcomm as a work-around.
   bool use_image_preserved = is_qualcomm_ || is_imagination_;
 
-  return static_cast<AsyncPixelTransferState*>(
-      new AsyncTransferStateAndroid(texture_id,
-                                    define_params,
-                                    wait_for_uploads,
-                                    wait_for_creation,
-                                    use_image_preserved));
+  return new AsyncTransferStateAndroid(texture_id,
+                                       define_params,
+                                       wait_for_uploads,
+                                       wait_for_creation,
+                                       use_image_preserved);
 }
 
 bool AsyncPixelTransferDelegateAndroid::BindCompletedAsyncTransfers() {
   bool texture_dirty = false;
   while(!pending_allocations_.empty()) {
     if (!pending_allocations_.front().get()) {
       pending_allocations_.pop_front();
       continue;
     }
     scoped_refptr<TransferStateInternal> state =
@@ skipping 149 matching lines @@
   return texture_upload_stats_->GetStats(NULL);
 }
 
 base::TimeDelta AsyncPixelTransferDelegateAndroid::GetTotalTextureUploadTime() {
   CHECK(texture_upload_stats_);
   base::TimeDelta total_texture_upload_time;
   texture_upload_stats_->GetStats(&total_texture_upload_time);
   return total_texture_upload_time;
 }
 
+bool AsyncPixelTransferDelegateAndroid::ProcessMorePendingTransfers() {
+  return false;
+}
+
+bool AsyncPixelTransferDelegateAndroid::NeedsProcessMorePendingTransfers() {
+  return false;
+}
+
+
 namespace {
 void SetGlParametersForEglImageTexture() {
   // These params are needed for EGLImage creation to succeed on several
   // Android devices. I couldn't find this requirement in the EGLImage
   // extension spec, but several devices fail without it.
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }
 } // namespace
@@ skipping 217 matching lines @@
   if (texture_upload_stats_) {
     texture_upload_stats_->AddUpload(
         base::TimeTicks::HighResNow() - begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx