gpu: Enable async uploads again.

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 <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 166 matching lines @@
 
   // Implement AsyncPixelTransferState:
   bool TransferIsInProgress() {
     return transfer_in_progress_;
   }
 
   void BindTransfer(AsyncTexImage2DParams* bound_params) {
     TRACE_EVENT2("gpu", "BindAsyncTransfer glEGLImageTargetTexture2DOES",
                  "width", late_bind_define_params_.width,
                  "height", late_bind_define_params_.height);
-
     DCHECK(bound_params);
     DCHECK(texture_id_);
-    DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
     *bound_params = late_bind_define_params_;
     if (!needs_late_bind_)
       return;
+    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_);
     needs_late_bind_ = false;
 
     DCHECK(CHECK_GL());
   }
@@ skipping 174 matching lines @@
       const AsyncMemoryParams& mem_params);
 
   int texture_upload_count_;
   base::TimeDelta total_texture_upload_time_;
   bool is_imagination_;
   bool is_qualcomm_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateAndroid);
 };
 
-namespace {
-// Imagination has some odd problems still.
-bool IsImagination() {
-  std::string vendor;
-  vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
-  return vendor.find("Imagination") != std::string::npos;
-}
-}
-
 // We only used threaded uploads when we can:
 // - Create EGLImages out of OpenGL textures (EGL_KHR_gl_texture_2D_image)
 // - Bind EGLImages to OpenGL textures (GL_OES_EGL_image)
 // - Use fences (to test for upload completion).
 scoped_ptr<AsyncPixelTransferDelegate>
     AsyncPixelTransferDelegate::Create(gfx::GLContext* context) {
   DCHECK(context);
   if (context->HasExtension("EGL_KHR_fence_sync") &&
       context->HasExtension("EGL_KHR_image") &&
       context->HasExtension("EGL_KHR_image_base") &&
       context->HasExtension("EGL_KHR_gl_texture_2D_image") &&
-      context->HasExtension("GL_OES_EGL_image") &&
-      !IsImagination()) {
+      context->HasExtension("GL_OES_EGL_image")) {
     return make_scoped_ptr(
         static_cast<AsyncPixelTransferDelegate*>(
             new AsyncPixelTransferDelegateAndroid()));
   } else {
     LOG(INFO) << "Async pixel transfers not supported";
     return make_scoped_ptr(
         static_cast<AsyncPixelTransferDelegate*>(
             new AsyncPixelTransferDelegateStub()));
   }
 }
@@ skipping 340 matching lines @@
     const AsyncMemoryParams& mem_params) {
   if (!is_imagination_)
     return false;
 
   // If the dimensions support fast async uploads, we can use the
   // normal async upload path for uploads.
   if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height))
     return false;
 
   // Fall back on a synchronous stub as we don't have a known fast path.
+  // Also, older ICS drivers crash when we do any glTexSubImage2D on the
+  // same thread. To work around this we do glTexImage2D instead. Since
+  // we didn't create an EGLImage for this texture (see above), this is
+  // okay, but it limits this API to full updates for now.
+  DCHECK(!state->egl_image_);
+  DCHECK_EQ(tex_params.xoffset, 0);
+  DCHECK_EQ(tex_params.yoffset, 0);
+  DCHECK_EQ(state->late_bind_define_params_.width, tex_params.width);
+  DCHECK_EQ(state->late_bind_define_params_.height, tex_params.height);
+  DCHECK_EQ(state->late_bind_define_params_.level, tex_params.level);
+  DCHECK_EQ(state->late_bind_define_params_.format, tex_params.format);
+  DCHECK_EQ(state->late_bind_define_params_.type, tex_params.type);
+
   void* data = GetAddress(mem_params.shared_memory,
                           mem_params.shm_data_offset);
   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
-    DoTexSubImage2D(tex_params, data);
+    // Note we use late_bind_define_params_ instead of tex_params.
+    // The DCHECKs above verify this is always the same.
+    DoTexImage2D(state->late_bind_define_params_, data);
   }
   texture_upload_count_++;
   total_texture_upload_time_ += base::TimeTicks::HighResNow() - begin_time;
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx