Make displayAsyncThen use the CompositeAndReadbackAsync path.

content/shell/renderer/test_runner/WebTestProxy.cpp

 // Copyright 2013 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 "content/shell/renderer/test_runner/WebTestProxy.h"
 
 #include <cctype>
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 466 matching lines @@
 
 void WebTestProxyBase::didCompositeAndReadback(const SkBitmap& bitmap) {
   TRACE_EVENT2("shell",
                "WebTestProxyBase::didCompositeAndReadback",
                "x",
                bitmap.info().fWidth,
                "y",
                bitmap.info().fHeight);
   SkCanvas canvas(bitmap);
   DrawSelectionRect(&canvas);
-  base::ResetAndReturn(&m_compositeAndReadbackCallback).Run(bitmap);
+  m_compositeAndReadbackCallbacks.front().Run(bitmap);
+  m_compositeAndReadbackCallbacks.pop_front();
 }
 
 void WebTestProxyBase::CapturePixelsAsync(
     base::Callback<void(const SkBitmap&)> callback) {
-  m_compositeAndReadbackCallback = callback;
   TRACE_EVENT0("shell", "WebTestProxyBase::CapturePixelsAsync");
 
+  m_compositeAndReadbackCallbacks.push_back(callback);
+
   // Do a layout here because it might leave compositing mode! x.x
   // TODO(danakj): Remove this when we have kForceCompositingMode everywhere.
   webWidget()->layout();
 
-  if (!webWidget()->compositeAndReadbackAsync(this)) {
+  if (!webWidget()->isAcceleratedCompositingActive()) {
     TRACE_EVENT0("shell",
                  "WebTestProxyBase::CapturePixelsAsync "
-                 "compositeAndReadbackAsync failed");
+                 "isAcceleratedCompositingActive false");
     didCompositeAndReadback(SkBitmap());
+    return;
   }
+
+  webWidget()->compositeAndReadbackAsync(this);
 }
 
 void WebTestProxyBase::setLogConsoleOutput(bool enabled)
 {
     m_logConsoleOutput = enabled;
 }
 
 void WebTestProxyBase::paintRect(const WebRect& rect)
 {
     DCHECK(!m_isPainting);
@@ skipping 75 matching lines @@
     float deviceScaleFactor = webView()->deviceScaleFactor();
     int scaledWidth = static_cast<int>(ceil(static_cast<float>(widgetSize.width) * deviceScaleFactor));
     int scaledHeight = static_cast<int>(ceil(static_cast<float>(widgetSize.height) * deviceScaleFactor));
     // We're allocating the canvas to be non-opaque (third parameter), so we
     // don't end up with uninitialized memory if a layout test doesn't damage
     // the entire view.
     m_canvas.reset(skia::CreateBitmapCanvas(scaledWidth, scaledHeight, false));
     return m_canvas.get();
 }
 
-void WebTestProxyBase::display(base::Closure callback)
-{
+void WebTestProxyBase::DisplayForSoftwareMode(const base::Closure& callback) {
     const blink::WebSize& size = webWidget()->size();
     WebRect rect(0, 0, size.width, size.height);
     m_paintRect = rect;
     paintInvalidatedRegion();
 
     if (!callback.is_null())
         callback.Run();
 }
 
+void WebTestProxyBase::DidDisplayAsync(const base::Closure& callback,
+                                       const SkBitmap& bitmap) {
+  if (!callback.is_null())
+    callback.Run();
+}
+
 void WebTestProxyBase::displayAsyncThen(base::Closure callback)
 {
-  // TODO(enne): When compositing, this should invoke a real rAF, paint,
-  // and commit.  For now, just make sure that displayAsync is actually
-  // async so that callers can't depend on synchronous behavior.
-  m_delegate->postTask(new ClosureTask(
-      this,
-      base::Bind(
-          &WebTestProxyBase::display, base::Unretained(this), callback)));
+  TRACE_EVENT0("shell", "WebTestProxyBase::displayAsyncThen");
+
+  // TODO(danakj): Just call CapturePixelsAsyc when we have
+  // kForceCompositingMode everywhere.
+
+  // Do a layout here because it might leave compositing mode! x.x
+  webWidget()->layout();

[abarth-chromium, 2014/05/05 22:37:43]

Will this change what we're testing by introducing another call to layout?  What
if the compositing mode changes while the callback is in flight?

[danakj, 2014/05/05 22:46:55]

This does add one additional layout.
If it leaves during the c&RAsync, and destroys the compositor, the callback will
return here, and we'll run the |callback| passed in here. I could have it run
the software display() in that case instead?

+
+  if (!webWidget()->isAcceleratedCompositingActive()) {
+    TRACE_EVENT0("shell",
+                 "WebTestProxyBase::displayAsyncThen "
+                 "isAcceleratedCompositingActive false");
+    m_delegate->postTask(
+        new ClosureTask(this,
+                        base::Bind(&WebTestProxyBase::DisplayForSoftwareMode,
+                                   base::Unretained(this),
+                                   callback)));
+    return;
+  }
+
+  m_compositeAndReadbackCallbacks.push_back(base::Bind(
+      &WebTestProxyBase::DidDisplayAsync, base::Unretained(this), callback));
+  webWidget()->compositeAndReadbackAsync(this);
 }
 
 void WebTestProxyBase::discardBackingStore()
 {
     m_canvas.reset();
 }
 
 WebMIDIClientMock* WebTestProxyBase::midiClientMock()
 {
     if (!m_midiClient.get())
@@ skipping 666 matching lines @@
 
 void WebTestProxyBase::resetInputMethod()
 {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
     if (m_webWidget)
         m_webWidget->confirmComposition();
 }
 
 }  // namespace content