Do not send a frame swap ack from the browser until the frame is drawn

content/browser/renderer_host/render_widget_host_impl.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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 769 matching lines @@
                                        int tag,
                                        const gfx::Size& page_size,
                                        const gfx::Size& desired_size) {
   // Ask the renderer to create a bitmap regardless of whether it's
   // hidden, being resized, redrawn, etc.  It resizes the web widget
   // to the page_size and then scales it to the desired_size.
   Send(new ViewMsg_PaintAtSize(routing_id_, dib_handle, tag,
                                page_size, desired_size));
 }
 
+void RenderWidgetHostImpl::SetAboutToWaitForBackingStoreCallback(
+    const base::Closure& about_to_wait_for_backing_store_callback) {
+  about_to_wait_for_backing_store_callback_ =
+      about_to_wait_for_backing_store_callback;
+}
+
 bool RenderWidgetHostImpl::TryGetBackingStore(const gfx::Size& desired_size,
                                               BackingStore** backing_store) {
   // Check if the view has an accelerated surface of the desired size.
   if (view_->HasAcceleratedSurface(desired_size)) {
     *backing_store = NULL;
     return true;
   }
 
   // Check for a software backing store of the desired size.
   *backing_store = BackingStoreManager::GetBackingStore(this, desired_size);
@@ skipping 49 matching lines @@
     TRACE_EVENT_ASYNC_BEGIN0(
         "renderer_host", "RenderWidgetHostImpl::repaint_ack_pending_", this);
     Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 
   TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS);
   TimeTicks end_time = TimeTicks::Now() + max_delay;
   do {
     TRACE_EVENT0("renderer_host", "GetBackingStore::WaitForUpdate");
 
+    // Release any backpressure preventing the renderer from generating new
+    // frames.
+    if (!about_to_wait_for_backing_store_callback_.is_null())
+      about_to_wait_for_backing_store_callback_.Run();

[ccameron, 2014/02/14 02:19:06]

The call that we need it before is this guy. It's a loop that pumps the renderer
for frames until it gets one of the right size.

[piman, 2014/02/14 02:59:02]

RWHVMac could send the ack right away when receiving the
AcceleratedBuffersSwapped if it's the wrong size?

You'd wrap the calls to GetBackingStore(true) by something like

BackingStoreMac* RWHVMac::GetBackingStoreSync() {
  waiting_for_backing_store_ = true;
  SendPendingAcks();
  BackingStoreMac* bs = rwh->GetBackingStore(true);
  waiting_for_backing_store_ = false;
  return bs;
}

Then in RWHVMac::AcceleratedSurfaceBuffersSwapped() {
  // [...]
  AddPendingSwapAck();     
  if (size != expected_size && waiting_for_backing_store_) {
    SendPendingAcks();
    return;
  }
}

That even lets you skip a bunch of the logic that you don't care about since
it's not a frame of the right size.

We do something essentially similar in RWHVAura, minus the "block the main
thread" part (instead we prevent the compositor from drawing). See the
RenderWidgetHostViewAura::ShouldSkipFrame and callers.

+
     // When we have asked the RenderWidget to resize, and we are still waiting
     // on a response, block for a little while to see if we can't get a response
     // before returning the old (incorrectly sized) backing store.
     IPC::Message msg;
     if (process_->WaitForBackingStoreMsg(routing_id_, max_delay, &msg)) {
       OnMessageReceived(msg);
 
       // For auto-resized views, current_size_ determines the view_size and it
       // may have changed during the handling of an UpdateRect message.
       if (should_auto_resize_)
@@ skipping 1680 matching lines @@
     }
   }
 
   // Add newly generated components into the latency info
   for (lc = new_components.begin(); lc != new_components.end(); ++lc) {
     latency_info->latency_components[lc->first] = lc->second;
   }
 }
 
 }  // namespace content