Delete background tab IOSurfaces on Mac.

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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/closure_blocks_leopard_compat.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #import "base/memory/scoped_nsobject.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/plugin_process_host.h"
 #import "content/browser/renderer_host/accelerated_plugin_view_mac.h"
 #include "content/browser/renderer_host/backing_store_mac.h"
+#include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/compositing_iosurface_mac.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
 #import "content/browser/renderer_host/text_input_client_mac.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/edit_command.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 219 matching lines @@
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       is_loading_(false),
       is_hidden_(false),
-      weak_factory_(this),
-      compositing_surface_(gfx::kNullPluginWindow) {
+      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() {
   UnlockMouse();
@@ skipping 676 matching lines @@
                                                     int32 route_id,
                                                     int32 gpu_host_id) {
   pending_swap_buffers_acks_.push_back(std::make_pair(route_id, gpu_host_id));
   if (!compositing_iosurface_.get() && !is_hidden_) {
     compositing_iosurface_.reset(CompositingIOSurfaceMac::Create());
   }
 
   if (compositing_iosurface_.get() && !is_hidden_) {
     last_frame_was_accelerated_ = true;
     compositing_iosurface_->SetIOSurface(surface_handle);
-    [cocoa_view_ setNeedsDisplay:YES];
+    // No need for presenting if we're already in a drawRect (it will be done
+    // later).
+    if (!about_to_validate_and_paint_) {
+      compositing_iosurface_->DrawIOSurface(cocoa_view_);
+      AckPendingCompositorSwapBuffers();
+    }
   } else {
     AckPendingCompositorSwapBuffers();
   }
 }
 
 void RenderWidgetHostViewMac::AckPendingCompositorSwapBuffers() {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewMac::AckPendingCompositorSwapBuffers");
   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));
 
-  if (params.window == compositing_surface_) {
+  // Compositor window is always gfx::kNullPluginWindow.
+  // TODO(jbates) This will be removed when there are no plugin windows.
+  if (params.window == gfx::kNullPluginWindow) {
     CompositorSwapBuffers(params.surface_handle, params.route_id, gpu_host_id);
   } 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);
     }
   }
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer");
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (params.window == compositing_surface_) {
+  // Compositor window is always gfx::kNullPluginWindow.
+  // TODO(jbates) This will be removed when there are no plugin windows.
+  if (params.window == gfx::kNullPluginWindow) {
     CompositorSwapBuffers(params.surface_handle, params.route_id, gpu_host_id);
   } 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);
     }
   }
 }
 
 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::AboutToWaitForUpdateMsg() {
+  // We want to get a fresh frame from the renderer, so ack any pending swaps to
+  // allow the renderer to produce new frames.
+  AckPendingCompositorSwapBuffers();
 }
 
 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
   // the information from the main tab for our window.
   NSWindow* enclosing_window = ApparentWindowForView(cocoa_view_);
   if (!enclosing_window)
     return gfx::Rect();
 
   NSRect bounds = [enclosing_window frame];
   return FlipNSRectToRectScreen(bounds);
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostViewMac::GetCompositingSurface() {
-  // compositing_surface_ is always gfx::kNullPluginWindow.
-  return gfx::GLSurfaceHandle(compositing_surface_, true);
+  // Compositor window is always gfx::kNullPluginWindow.
+  // TODO(jbates) This will be removed when there are no plugin windows.
+  return gfx::GLSurfaceHandle(gfx::kNullPluginWindow, true);
 }
 
 void RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance(
       CGLContextObj context,
       gfx::PluginWindowHandle plugin_handle,
       NSSize size) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance");
   // Called on the display link thread.
   CGLSetCurrentContext(context);
@@ skipping 270 matching lines @@
         [view performSelector:nonWebContentViewSelector]) {
       // The cursor is over a nonWebContentView - ignore this mouse event.
       return YES;
     }
     view = [view superview];
   }
   return NO;
 }
 
 - (void)mouseEvent:(NSEvent*)theEvent {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::mouseEvent");
   if (delegate_ && [delegate_ respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [delegate_ handleEvent:theEvent];
     if (handled)
       return;
   }
 
   if ([self shouldIgnoreMouseEvent:theEvent]) {
     // If this is the first such event, send a mouse exit to the host view.
     if (!mouseEventWasIgnored_ && renderWidgetHostView_->render_widget_host_) {
       WebMouseEvent exitEvent =
@@ skipping 141 matching lines @@
   if (delegate_ && [delegate_ respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [delegate_ handleEvent:theEvent];
     if (handled)
       return;
   }
 
   [self keyEvent:theEvent wasKeyEquivalent:NO];
 }
 
 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::keyEvent");
   DCHECK([theEvent type] != NSKeyDown ||
          !equiv == !([theEvent modifierFlags] & NSCommandKeyMask));
 
   if ([theEvent type] == NSFlagsChanged) {
     // Ignore NSFlagsChanged events from the NumLock and Fn keys as
     // Safari does in -[WebHTMLView flagsChanged:] (of "WebHTMLView.mm").
     int keyCode = [theEvent keyCode];
     if (!keyCode || keyCode == 10 || keyCode == 63)
       return;
   }
@@ skipping 305 matching lines @@
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
     [[NSColor whiteColor] set];
     NSRectFill(r);
   }
 }
 
 - (void)drawRect:(NSRect)dirtyRect {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::drawRect");
   if (!renderWidgetHostView_->render_widget_host_) {
     // TODO(shess): Consider using something more noticable?
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     return;
   }
 
+  DCHECK(!renderWidgetHostView_->about_to_validate_and_paint_);
+
+  // GetBackingStore works for both software and accelerated frames. If a
+  // SwapBuffers occurs while GetBackingStore is blocking, we will continue to
+  // 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_) {
-    // Draw transparency to expose the GL underlay:
-    // TODO(jbates) avoid doing this every frame.
-    [[NSColor clearColor] set];
-    NSRectFill(dirtyRect);
+    // Delete software backingstore.
+    // TODO(jbates) Only do this on first GPU frame after software frame.
+    BackingStoreManager::RemoveBackingStore(
+        renderWidgetHostView_->render_widget_host_);
+
+    {
+      TRACE_EVENT0("browser", "NSRectFill");
+      // Draw transparency to expose the GL underlay:
+      // TODO(jbates) avoid doing this every frame.
+      [[NSColor clearColor] set];
+      NSRectFill(dirtyRect);
+    }
 
     renderWidgetHostView_->compositing_iosurface_->DrawIOSurface(self);
     renderWidgetHostView_->AckPendingCompositorSwapBuffers();
     return;
   }
 
+  // Forget IOSurface since we are drawing a software frame now.
+  if (renderWidgetHostView_->compositing_iosurface_.get() &&
+      renderWidgetHostView_->compositing_iosurface_->HasIOSurface())
+    renderWidgetHostView_->compositing_iosurface_->UnrefIOSurface();
+
   // In case the last frame was accelerated, ack any pending swaps to unblock
   // the GPU process.
   renderWidgetHostView_->AckPendingCompositorSwapBuffers();
 
-  DCHECK(!renderWidgetHostView_->about_to_validate_and_paint_);
-
-  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;
-
   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
     // smaller and the renderer hasn't yet repainted.
     int yOffset = NSHeight([self bounds]) - backingStore->size().height();
 
@@ skipping 969 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