Defer CGLFlushDrawable until OSX-requested drawRect to avoid spinning when window is obscured.

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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_view_mac.h"
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 257 matching lines @@
       weak_factory_(this) {
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
   cocoa_view_ = [[[RenderWidgetHostViewCocoa alloc]
                   initWithRenderWidgetHostViewMac:this] autorelease];
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
+  AckPendingSwapBuffers();
   UnlockMouse();
 }
 
 void RenderWidgetHostViewMac::SetDelegate(
     NSObject<RenderWidgetHostViewMacDelegate>* delegate) {
   [cocoa_view_ setRWHVDelegate:delegate];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, RenderWidgetHostView implementation:
@@ skipping 73 matching lines @@
   render_widget_host_->WasRestored();
 
   // We're messing with the window, so do this to ensure no flashes.
   [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (is_hidden_)
     return;
 
+  // Send ACKs for any pending SwapBuffers (if any) since we won't be displaying
+  // them and the GPU process is waiting.

[Ken Russell (switch to Gerrit), 2012/05/17 20:28:34]

Is there any issue with this being inside the short-circuit (after the
is_hidden_ test above)? Just making sure this was tested.

[jbates, 2012/05/18 00:31:47]

The code at line 953 ensures that we only need to Ack during the transition to
is_hidden_ == true. (Swaps will be acked immediately while is_hidden_ is true.)

+  AckPendingSwapBuffers();
+
   // If we receive any more paint messages while we are hidden, we want to
   // ignore them so we don't re-allocate the backing store.  We will paint
   // everything again when we become selected again.
   is_hidden_ = true;
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_host_->WasHidden();
 
   // There can be a transparent flash as this view is removed and the next is
@@ skipping 272 matching lines @@
       [cocoa_view_ displayIfNeeded];
   }
 }
 
 void RenderWidgetHostViewMac::RenderViewGone(base::TerminationStatus status,
                                              int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewMac::Destroy() {
+  AckPendingSwapBuffers();
+
   // On Windows, popups are implemented with a popup window style, so that when
   // an event comes in that would "cancel" it, it receives the OnCancelMode
   // message and can kill itself. Alas, on the Mac, views cannot capture events
   // outside of themselves. On Windows, if Destroy is being called on a view,
   // then the event causing the destroy had also cancelled any popups by the
   // time Destroy() was called. On the Mac we have to destroy all the popups
   // ourselves.
 
   // Depth-first destroy all popups. Use ShutdownHost() to enforce
   // deepest-first ordering.
@@ skipping 262 matching lines @@
     int32 width,
     int32 height,
     TransportDIB::Handle transport_dib) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   plugin_container_manager_.SetSizeAndTransportDIB(window,
                                                    width,
                                                    height,
                                                    transport_dib);
 }
 
-void RenderWidgetHostViewMac::CompositorSwapBuffers(uint64 surface_handle) {
+bool RenderWidgetHostViewMac::CompositorSwapBuffers(uint64 surface_handle) {
   if (is_hidden_)
-    return;
+    return true;
 
   if (!compositing_iosurface_.get())
     compositing_iosurface_.reset(CompositingIOSurfaceMac::Create());
 
   if (!compositing_iosurface_.get())
-    return;
+    return true;
 
   compositing_iosurface_->SetIOSurface(surface_handle);
+
+  GotAcceleratedFrame();
+
   // No need to draw the surface if we are inside a drawRect. It will be done
   // later.
-  if (!about_to_validate_and_paint_)
-    compositing_iosurface_->DrawIOSurface(cocoa_view_);
-  GotAcceleratedFrame();
+  if (!about_to_validate_and_paint_) {
+    // Trigger a drawRect, but don't invalidate the whole window because it
+    // is expensive to clear it with transparency to expose the GL underneath.
+    [cocoa_view_ setNeedsDisplayInRect:NSMakeRect(0, 0, 1, 1)];
+
+    // While resizing, OSX fails to call drawRect on the NSView unless the
+    // window size has changed. That means we won't see animations update if the
+    // user has the mouse button held down, but is not currently changing the
+    // size of the window. To work around that, display here while resizing.
+    if ([cocoa_view_ inLiveResize])
+      [cocoa_view_ displayIfNeeded];
+  }
+  return false;
+}
+
+void RenderWidgetHostViewMac::AckPendingSwapBuffers() {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewMac::AckPendingSwapBuffers");
+  while (!pending_swap_buffers_acks_.empty()) {
+    if (pending_swap_buffers_acks_.front().first != 0) {
+      RenderWidgetHostImpl::AcknowledgeSwapBuffers(
+          pending_swap_buffers_acks_.front().first,
+          pending_swap_buffers_acks_.front().second);
+    }
+    pending_swap_buffers_acks_.erase(pending_swap_buffers_acks_.begin());
+  }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
+                                                      gpu_host_id));
 
   // Compositor window is always gfx::kNullPluginWindow.
   // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
   // plugin windows.
   if (params.window == gfx::kNullPluginWindow) {
-    CompositorSwapBuffers(params.surface_handle);
+    if (CompositorSwapBuffers(params.surface_handle))
+      AckPendingSwapBuffers();
   } else {
     // Deprecated accelerated plugin code path.
     AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
     DCHECK(view);
     if (view) {
       plugin_container_manager_.SetSurfaceWasPaintedTo(params.window,
                                                        params.surface_handle);
 
       // The surface is hidden until its first paint, to not show garbage.
       if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
         [view setHidden:NO];
       [view drawView];
     }
-  }
-
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id,
-                                                 gpu_host_id);
+    AckPendingSwapBuffers();
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  pending_swap_buffers_acks_.push_back(std::make_pair(params.route_id,
+                                                      gpu_host_id));
 
   // Compositor window is always gfx::kNullPluginWindow.
   // TODO(jbates) http://crbug.com/105344 This will be removed when there are no
   // plugin windows.
   if (params.window == gfx::kNullPluginWindow) {
-    CompositorSwapBuffers(params.surface_handle);
+    if (CompositorSwapBuffers(params.surface_handle))
+      AckPendingSwapBuffers();
   } else {
     // Deprecated accelerated plugin code path.
     AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
     DCHECK(view);
     if (view) {
       plugin_container_manager_.SetSurfaceWasPaintedTo(
           params.window,
           params.surface_handle,
           gfx::Rect(params.x, params.y, params.width, params.height));
 
       // The surface is hidden until its first paint, to not show garbage.
       if (plugin_container_manager_.SurfaceShouldBeVisible(params.window))
         [view setHidden:NO];
       [view drawView];
     }
-  }
-
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgePostSubBuffer(
-        params.route_id, gpu_host_id);
+    AckPendingSwapBuffers();
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSuspend() {
   if (compositing_iosurface_.get())
     compositing_iosurface_->UnrefIOSurface();
 }
 
 bool RenderWidgetHostViewMac::HasAcceleratedSurface(
       const gfx::Size& desired_size) {
   return last_frame_was_accelerated_ &&
          compositing_iosurface_.get() &&
          compositing_iosurface_->HasIOSurface() &&
          (desired_size.IsEmpty() ||
           compositing_iosurface_->io_surface_size() == desired_size);
 }
 
+void RenderWidgetHostViewMac::AboutToWaitForBackingStoreMsg() {
+  AckPendingSwapBuffers();
+}
+
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
 }
 
 void RenderWidgetHostViewMac::GetScreenInfo(WebKit::WebScreenInfo* results) {
   *results = WebKit::WebScreenInfoFactory::screenInfo(GetNativeView());
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetRootWindowBounds() {
   // TODO(shess): In case of !window, the view has been removed from
   // the view hierarchy because the tab isn't main.  Could retrieve
@@ skipping 91 matching lines @@
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
 void RenderWidgetHostViewMac::GotAcceleratedFrame() {
   if (!last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = true;
 
     // Need to wipe the software view with transparency to expose the GL
     // underlay. Invalidate the whole window to do that.
-    if (!about_to_validate_and_paint_) {
+    if (!about_to_validate_and_paint_)
       [cocoa_view_ setNeedsDisplay:YES];
-      [cocoa_view_ displayIfNeeded];
-    }
 
     // Delete software backingstore.
     BackingStoreManager::RemoveBackingStore(render_widget_host_);
   }
 }
 
 void RenderWidgetHostViewMac::GotSoftwareFrame() {
   if (last_frame_was_accelerated_) {
     last_frame_was_accelerated_ = false;
 
+    AckPendingSwapBuffers();
+
     // Forget IOSurface since we are drawing a software frame now.
     if (compositing_iosurface_.get() &&
         compositing_iosurface_->HasIOSurface()) {
       compositing_iosurface_->UnrefIOSurface();
     }
   }
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetViewCocoaBounds() const {
   return gfx::Rect(NSRectToCGRect([cocoa_view_ bounds]));
@@ skipping 707 matching lines @@
   // blit the IOSurface below.
   renderWidgetHostView_->about_to_validate_and_paint_ = true;
   BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
       renderWidgetHostView_->render_widget_host_->GetBackingStore(true));
   renderWidgetHostView_->about_to_validate_and_paint_ = false;
 
   const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
 
   if (renderWidgetHostView_->last_frame_was_accelerated_ &&
       renderWidgetHostView_->compositing_iosurface_.get()) {
-    // Note that this code path is only executed when there's window damage
-    // (when the window is foregrounded, for example). Normally, GPU frames
-    // arrive and are drawn during AcceleratedSurfaceBuffersSwapped.
     {
       TRACE_EVENT0("browser", "NSRectFill");
       // Draw transparency to expose the GL underlay. NSRectFill is extremely
       // slow (15ms for a window on a fast MacPro), so this is only done for the
       // dirty rect. The composited swap-buffers typically happens outside of
       // drawRect to avoid invalidating the entire NSView.
       [[NSColor clearColor] set];
       NSRectFill(dirtyRect);
     }
 
     renderWidgetHostView_->compositing_iosurface_->DrawIOSurface(self);
+    renderWidgetHostView_->AckPendingSwapBuffers();
     return;
   }
 
   if (backingStore) {
     gfx::Rect bitmapRect(0, 0,
                          backingStore->size().width(),
                          backingStore->size().height());
 
     // Specify the proper y offset to ensure that the view is rooted to the
     // upper left corner.  This can be negative, if the window was resized
@@ skipping 972 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end