gpu: Add the ability to wait on upload completion.

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"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "ui/gl/async_pixel_transfer_delegate.h"
 #include "ui/gl/async_pixel_transfer_delegate_stub.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/safe_shared_memory_pool.h"
 
@@ skipping 165 matching lines @@
     g_transfer_thread = LAZY_INSTANCE_INITIALIZER;
 
 base::MessageLoopProxy* transfer_message_loop_proxy() {
   return g_transfer_thread.Pointer()->message_loop_proxy();
 }
 
 SafeSharedMemoryPool* safe_shared_memory_pool() {
   return g_transfer_thread.Pointer()->safe_shared_memory_pool();
 }
 
+void SignalCompletion(base::WaitableEvent* completion) {
+  completion->Signal();
+}
 
 } // 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,
@@ skipping 162 matching lines @@
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateAndroid> {
  public:
   AsyncPixelTransferDelegateAndroid();
   virtual ~AsyncPixelTransferDelegateAndroid();
 
   // implement AsyncPixelTransferDelegate:
   virtual void AsyncNotifyCompletion(
       const AsyncMemoryParams& mem_params,
       const CompletionCallback& callback) OVERRIDE;
+  virtual void WaitOnUploadCompletion() OVERRIDE;
   virtual void AsyncTexImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual void AsyncTexSubImage2D(
       AsyncPixelTransferState* state,
       const AsyncTexSubImage2DParams& tex_params,
       const AsyncMemoryParams& mem_params) OVERRIDE;
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
@@ skipping 104 matching lines @@
       FROM_HERE,
       base::Bind(&AsyncPixelTransferDelegateAndroid::PerformNotifyCompletion,
                  mem_params,
                  base::Owned(
                      new ScopedSafeSharedMemory(safe_shared_memory_pool(),
                                                 mem_params.shared_memory,
                                                 mem_params.shm_size)),
                  callback));
 }
 
+void AsyncPixelTransferDelegateAndroid::WaitOnUploadCompletion() {
+  // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
+  int default_nice_value = 0;  // Default priority.
+  int idle_nice_value    = 10; // Idle priority.
+  setpriority(PRIO_PROCESS,
+              g_transfer_thread.Pointer()->thread_id(),
+              default_nice_value);
+
+  base::WaitableEvent completion(true, false);
+  transfer_message_loop_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&SignalCompletion, &completion));
+  completion.Wait();
+
+  // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
+  setpriority(PRIO_PROCESS,
+              g_transfer_thread.Pointer()->thread_id(),
+              idle_nice_value);
+}
+
 void AsyncPixelTransferDelegateAndroid::AsyncTexImage2D(
     AsyncPixelTransferState* transfer_state,
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params) {
   scoped_refptr<TransferStateInternal> state =
       static_cast<AsyncTransferStateAndroid*>(transfer_state)->internal_.get();
   DCHECK(mem_params.shared_memory);
   DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size,
             mem_params.shm_size);
   DCHECK(state);
@@ skipping 309 matching lines @@
   if (texture_upload_stats_) {
     texture_upload_stats_->AddUpload(
         base::TimeTicks::HighResNow() - begin_time);
   }
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx