gpu: Finish after EGLImage creation on Qualcomm

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 @@
 } // namespace
 
 // Class which holds async pixel transfers state (EGLImage).
 // The EGLImage is accessed by either thread, but everything
 // else accessed only on the main thread.
 class TransferStateInternal
     : public base::RefCountedThreadSafe<TransferStateInternal> {
  public:
   explicit TransferStateInternal(GLuint texture_id,
                                  bool wait_for_uploads,
+                                 bool wait_for_creation,
                                  bool use_image_preserved)
       : texture_id_(texture_id),
         thread_texture_id_(0),
         needs_late_bind_(false),
         transfer_completion_(true, true),
         egl_image_(EGL_NO_IMAGE_KHR),
         wait_for_uploads_(wait_for_uploads),
+        wait_for_creation_(wait_for_creation),
         use_image_preserved_(use_image_preserved) {
     static const AsyncTexImage2DParams zero_params = {0, 0, 0, 0, 0, 0, 0, 0};
     late_bind_define_params_ = zero_params;
   }
 
   // Implement AsyncPixelTransferState:
   bool TransferIsInProgress() {
     return !transfer_completion_.IsSignaled();
   }
 
@@ skipping 43 matching lines @@
         egl_attrib_list);
 
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
   }
 
   void CreateEglImageOnUploadThread() {
     CreateEglImage(thread_texture_id_);
   }
 
   void CreateEglImageOnMainThreadIfNeeded() {
-    if (egl_image_ == EGL_NO_IMAGE_KHR)
+    if (egl_image_ == EGL_NO_IMAGE_KHR) {
       CreateEglImage(texture_id_);
+      if (wait_for_creation_) {
+        TRACE_EVENT0("gpu", "glFinish creation");
+        glFinish();
+      }
+    }
   }
 
   void WaitForLastUpload() {
     // This glFinish is just a safe-guard for if uploads have some
     // GPU action that needs to occur. We could use fences and try
     // to do this less often. However, on older drivers fences are
     // not always reliable (eg. Mali-400 just blocks forever).
     if (wait_for_uploads_) {
       TRACE_EVENT0("gpu", "glFinish");
       glFinish();
@@ skipping 47 matching lines @@
   // Indicates that an async transfer is in progress.
   base::WaitableEvent transfer_completion_;
 
   // It would be nice if we could just create a new EGLImage for
   // every upload, but I found that didn't work, so this stores
   // one for the lifetime of the texture.
   EGLImageKHR egl_image_;
 
   // Customize when we block on fences (these are work-arounds).
   bool wait_for_uploads_;
+  bool wait_for_creation_;
   bool use_image_preserved_;
 };
 
 // Android needs thread-safe ref-counting, so this just wraps
 // an internal thread-safe ref-counted state object.
 class AsyncTransferStateAndroid : public AsyncPixelTransferState {
  public:
   explicit AsyncTransferStateAndroid(GLuint texture_id,
                                      bool wait_for_uploads,
+                                     bool wait_for_creation,
                                      bool use_image_preserved)
       : internal_(new TransferStateInternal(texture_id,
                                             wait_for_uploads,
+                                            wait_for_creation,
                                             use_image_preserved)) {
   }
   virtual ~AsyncTransferStateAndroid() {}
   virtual bool TransferIsInProgress() OVERRIDE {
       return internal_->TransferIsInProgress();
   }
   virtual void BindTransfer(AsyncTexImage2DParams* bound_params) OVERRIDE {
       internal_->BindTransfer(bound_params);
   }
   scoped_refptr<TransferStateInternal> internal_;
@@ skipping 99 matching lines @@
 }
 
 AsyncPixelTransferState*
     AsyncPixelTransferDelegateAndroid::
         CreateRawPixelTransferState(GLuint texture_id) {
 
   // We can't wait on uploads on imagination (it can take 200ms+).
   // In practice, they are complete when the CPU glTexSubImage2D completes.
   bool wait_for_uploads = !is_imagination_;
 
+  // Qualcomm runs into texture corruption problems if the same texture is
+  // uploaded to with both async and normal uploads. Synchronize after EGLImage
+  // 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,
                                     wait_for_uploads,
+                                    wait_for_creation,
                                     use_image_preserved));
 }
 
 void AsyncPixelTransferDelegateAndroid::AsyncNotifyCompletion(
     const AsyncMemoryParams& mem_params,
     const CompletionCallback& callback) {
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
   // Post a PerformNotifyCompletion task to the upload thread. This task
@@ skipping 357 matching lines @@
   if (texture_upload_stats_) {
     texture_upload_stats_->AddUpload(
         base::TimeTicks::HighResNow() - begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx