cc: Make async readback path use async glRreadPixels.

cc/trees/thread_proxy.cc

 // Copyright 2011 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 "cc/trees/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 517 matching lines @@
   first_output_surface_ = first_output_surface.Pass();
 
   started_ = true;
 }
 
 void ThreadProxy::Stop() {
   TRACE_EVENT0("cc", "ThreadProxy::Stop");
   DCHECK(IsMainThread());
   DCHECK(started_);
 
-  // Synchronously deletes the impl.
+  // Synchronously finishes pending GL operations and deletes the impl.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     CompletionEvent completion;
     Proxy::ImplThread()->PostTask(
+        base::Bind(&ThreadProxy::FinishGLOnImplThread,
+                   impl_thread_weak_ptr_,
+                   &completion));
+    completion.Wait();
+  } {

[piman, 2013/04/27 00:42:25]

nit: we usually put those on separate lines.

Also, why do they need to be 2 separate tasks?

[danakj, 2013/04/29 14:59:05]

So, my thinking was that Finish will cause callbacks to be queued, but not run.
And we want them to run before we destroy the GLRenderer, or we'll lose those
readback requests.

[piman, 2013/04/29 17:29:13]

Ok, I see. I didn't think it would generally work without race, but thinking
about it some more, it probably does:
- on gpu process, the sync point retire would be passed before the Finish is
done, so the signal IPC would be sent before the FlushSync reply
- on the IO thread, the signal task would be posted before the SyncMessageFilter
gets signalled to continue
- so by the time FinishGLOnImplThread signals the main thread, the task is
posted to finish the readback on the compositor thread, before the task is
posted for the LayerTreeHostClosedOnImplThread so we're good.

Definitely worth a comment though.

[danakj, 2013/04/30 01:30:52]

Done.

+    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+
+    CompletionEvent completion;
+    Proxy::ImplThread()->PostTask(
         base::Bind(&ThreadProxy::LayerTreeHostClosedOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion));
     completion.Wait();
   }
 
   weak_factory_.InvalidateWeakPtrs();
 
   DCHECK(!layer_tree_host_impl_.get());  // verify that the impl deleted.
   layer_tree_host_ = NULL;
@@ skipping 611 matching lines @@
         set_offscreen_context_provider(offscreen_context_provider);
 
     scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
   } else if (offscreen_context_provider) {
     offscreen_context_provider->VerifyContexts();
   }
 
   completion->Signal();
 }
 
+void ThreadProxy::FinishGLOnImplThread(CompletionEvent* completion) {
+  TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");

[piman, 2013/04/27 00:42:25]

nit: copy & paste of trace, I saw that.

[danakj, 2013/04/29 14:59:05]

Done. *^_^*

+  DCHECK(IsImplThread());
+  if (layer_tree_host_impl_->resource_provider())
+    layer_tree_host_impl_->resource_provider()->Finish();
+  completion->Signal();
+}
+
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
   layer_tree_host_impl_->EnableVSyncNotification(false);
   input_handler_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   scheduler_on_impl_thread_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
@@ skipping 156 matching lines @@
 
 void ThreadProxy::DidReceiveLastInputEventForVSync(
     base::TimeTicks frame_time) {
   if (render_vsync_notification_enabled_) {
     TRACE_EVENT0("cc", "ThreadProxy::DidReceiveLastInputEventForVSync");
     DidVSync(frame_time);
   }
 }
 
 }  // namespace cc