Mac ÜC: Enable GPU back-pressure from the browser to the renderer

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"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
-#include "content/browser/compositor/browser_compositor_view_mac.h"
 #include "content/browser/compositor/resize_lock.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/compositing_iosurface_context_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_layer_mac.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_dictionary_helper.h"
@@ skipping 376 matching lines @@
 ui::Layer* RenderWidgetHostViewMac::GetLayer() {
   return root_layer_.get();
 }
 
 RenderWidgetHostImpl* RenderWidgetHostViewMac::GetHost() {
   return render_widget_host_;
 }
 
 void RenderWidgetHostViewMac::SchedulePaintInRect(
     const gfx::Rect& damage_rect_in_dip) {
-  [browser_compositor_view_ compositor]->Draw();
+  if (browser_compositor_lock_)
+    browser_compositor_damaged_during_lock_ = true;
+  else
+    [browser_compositor_view_ compositor]->ScheduleFullRedraw();
+}
+
+void RenderWidgetHostViewMac::DelegatedCompositorDidSwapBuffers() {
+  // If this view is not visible then do not lock the compositor, because the
+  // wait for the surface to be drawn will time out.
+  NSWindow* window = [cocoa_view_ window];
+  if (!window)
+    return;
+  if (window && [window respondsToSelector:@selector(occlusionState)]) {
+    bool window_is_occluded =
+        !([window occlusionState] & NSWindowOcclusionStateVisible);
+    if (window_is_occluded)
+      return;
+  }
+  browser_compositor_lock_ =
+      [browser_compositor_view_ compositor]->GetCompositorLock();
+}
+
+void RenderWidgetHostViewMac::DelegatedCompositorAbortedSwapBuffers() {
+  PostReleaseBrowserCompositorLock();
 }
 
 bool RenderWidgetHostViewMac::IsVisible() {
   return !render_widget_host_->is_hidden();
 }
 
 gfx::Size RenderWidgetHostViewMac::DesiredFrameSize() {
   return GetViewBounds().size();
 }
 
@@ skipping 64 matching lines @@
   }
 
   render_widget_host_->SetView(this);
 }
 
 RenderWidgetHostViewMac::~RenderWidgetHostViewMac() {
   // This is being called from |cocoa_view_|'s destructor, so invalidate the
   // pointer.
   cocoa_view_ = nil;
 
-  // Delete the delegated frame state.
-  delegated_frame_host_.reset();
-  root_layer_.reset();
-
   UnlockMouse();
 
   // Make sure that the layer doesn't reach into the now-invalid object.
   DestroyCompositedIOSurfaceAndLayer(kDestroyContext);
   DestroySoftwareLayer();
 
   // We are owned by RenderWidgetHostViewCocoa, so if we go away before the
   // RenderWidgetHost does we need to tell it not to hold a stale pointer to
   // us.
   if (render_widget_host_)
@@ skipping 291 matching lines @@
   CGDirectDisplayID display_id = [screen_number unsignedIntValue];
 
   display_link_ = DisplayLinkMac::GetForDisplay(display_id);
   if (!display_link_) {
     // Note that on some headless systems, the display link will fail to be
     // created, so this should not be a fatal error.
     LOG(ERROR) << "Failed to create display link.";
   }
 }
 
+void RenderWidgetHostViewMac::PostReleaseBrowserCompositorLock() {
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&RenderWidgetHostViewMac::ReleaseBrowserCompositorLock,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void RenderWidgetHostViewMac::ReleaseBrowserCompositorLock() {
+  if (!browser_compositor_view_)
+    return;
+
+  browser_compositor_lock_ = NULL;
+  if (browser_compositor_damaged_during_lock_) {
+    browser_compositor_damaged_during_lock_ = false;
+    [browser_compositor_view_ compositor]->ScheduleFullRedraw();
+  }
+}
+
 void RenderWidgetHostViewMac::SendVSyncParametersToRenderer() {
   if (!render_widget_host_ || !display_link_)
     return;
 
   base::TimeTicks timebase;
   base::TimeDelta interval;
   if (!display_link_->GetVSyncParameters(&timebase, &interval))
     return;
 
   render_widget_host_->UpdateVSyncParameters(timebase, interval);
@@ skipping 36 matching lines @@
     [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::WasHidden() {
   if (render_widget_host_->is_hidden())
     return;
 
   // Any pending frames will not be displayed until this is shown again. Ack
   // them now.
   SendPendingSwapAck();
+  PostReleaseBrowserCompositorLock();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   render_widget_host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
   if (delegated_frame_host_)
     delegated_frame_host_->WasHidden();
 
   // There can be a transparent flash as this view is removed and the next is
   // added, because of OSX windowing races between displaying the contents of
@@ skipping 204 matching lines @@
 
   [fullscreen_window_manager_ exitFullscreenMode];
   fullscreen_window_manager_.reset();
   [pepper_fullscreen_window_ close];
 
   // This can be called as part of processing the window's responder
   // chain, for instance |-performKeyEquivalent:|.  In that case the
   // object needs to survive until the stack unwinds.
   pepper_fullscreen_window_.autorelease();
 
+  // Delete the delegated frame state, which will reach back into
+  // render_widget_host_.
+  browser_compositor_lock_ = NULL;
+  [browser_compositor_view_ resetClient];
+  delegated_frame_host_.reset();
+  root_layer_.reset();
+
   // We get this call just before |render_widget_host_| deletes
   // itself.  But we are owned by |cocoa_view_|, which may be retained
   // by some other code.  Examples are WebContentsViewMac's
   // |latent_focus_view_| and TabWindowController's
   // |cachedContentView_|.
   render_widget_host_ = NULL;
 }
 
 // Called from the renderer to tell us what the tooltip text should be. It
 // calls us frequently so we need to cache the value to prevent doing a lot
@@ skipping 768 matching lines @@
   }
   return false;
 }
 
 void RenderWidgetHostViewMac::OnSwapCompositorFrame(
     uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewMac::OnSwapCompositorFrame");
 
   if (frame->delegated_frame_data) {
     if (!browser_compositor_view_) {
-      browser_compositor_view_.reset(
-          [[BrowserCompositorViewMac alloc] initWithSuperview:cocoa_view_]);
+      browser_compositor_view_.reset([[BrowserCompositorViewMac alloc]
+          initWithSuperview:cocoa_view_ withClient:this]);
       root_layer_.reset(new ui::Layer(ui::LAYER_TEXTURED));
       delegated_frame_host_.reset(new DelegatedFrameHost(this));
       [browser_compositor_view_ compositor]->SetRootLayer(root_layer_.get());
     }
 
     float scale_factor = frame->metadata.device_scale_factor;
     gfx::Size dip_size = ToCeiledSize(frame->metadata.viewport_size);
     gfx::Size pixel_size = ConvertSizeToPixel(
         scale_factor, dip_size);
     [browser_compositor_view_ compositor]->SetScaleAndSize(
@@ skipping 557 matching lines @@
       [software_layer_ setFrame:new_background_frame];
     }
   }
 }
 
 SkBitmap::Config RenderWidgetHostViewMac::PreferredReadbackFormat() {
   return SkBitmap::kARGB_8888_Config;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// BrowserCompositorViewMacClient, public:
+
+void RenderWidgetHostViewMac::BrowserCompositorDidDrawFrame() {
+  PostReleaseBrowserCompositorLock();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // CompositingIOSurfaceLayerClient, public:
 
 void RenderWidgetHostViewMac::AcceleratedLayerDidDrawFrame(bool succeeded) {
   SendPendingLatencyInfoToHost();
   SendPendingSwapAck();
   if (!succeeded)
     GotAcceleratedCompositingError();
 }
 
 }  // namespace content
@@ skipping 1890 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end