Unobfuscate RWHVMac accelerated compositing code path by separating it from plugin code

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/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"
 #include "content/public/browser/browser_thread.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),
-      accelerated_compositing_active_(false),
-      needs_gpu_visibility_update_after_repaint_(false),
       compositing_surface_(gfx::kNullPluginWindow) {
   // |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() {
@@ skipping 74 matching lines @@
 }
 
 void RenderWidgetHostViewMac::DidBecomeSelected() {
   if (!is_hidden_)
     return;
 
   if (tab_switch_paint_time_.is_null())
     tab_switch_paint_time_ = base::TimeTicks::Now();
   is_hidden_ = false;
   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;
 
   // 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;
 
+  // Send ACKs for any pending SwapBuffers (if any) since we won't be displaying
+  // them and the GPU process is waiting.
+  AckPendingCompositorSwapBuffers();
+
   // 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
+  // added, because of OSX windowing races between displaying the contents of
+  // the NSView and its corresponding OpenGL context.
+  // disableScreenUpdatesUntilFlush prevents the transparent flash by avoiding
+  // screen updates until the next tab draws.
+  [[cocoa_view_ window] disableScreenUpdatesUntilFlush];
 }
 
 void RenderWidgetHostViewMac::SetSize(const gfx::Size& size) {
   gfx::Rect rect = GetViewBounds();
   rect.set_size(size);
   SetBounds(rect);
 }
 
 void RenderWidgetHostViewMac::SetBounds(const gfx::Rect& rect) {
   // |rect.size()| is view coordinates, |rect.origin| is screen coordinates,
@@ skipping 249 matching lines @@
           invalid_rect_ = NSUnionRect(invalid_rect_, ns_rect);
         }
       } else {
         [cocoa_view_ setNeedsDisplayInRect:ns_rect];
       }
     }
 
     if (!about_to_validate_and_paint_)
       [cocoa_view_ displayIfNeeded];
   }
-
-  // If |about_to_validate_and_paint_| is set, then -drawRect: is on the stack
-  // and it's not allowed to call -setHidden on the accelerated view.  In that
-  // case, -callSetNeedsDisplayInRect: will hide it later.
-  // If |about_to_validate_and_paint_| is not set, do it now.
-  if (!about_to_validate_and_paint_)
-    HandleDelayedGpuViewHiding();
 }
 
 void RenderWidgetHostViewMac::RenderViewGone(base::TerminationStatus status,
                                              int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewMac::Destroy() {
   // 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
@@ skipping 228 matching lines @@
 
 AcceleratedPluginView* RenderWidgetHostViewMac::ViewForPluginWindowHandle(
     gfx::PluginWindowHandle window) {
   PluginViewMap::iterator it = plugin_views_.find(window);
   DCHECK(plugin_views_.end() != it);
   if (plugin_views_.end() == it)
     return nil;
   return it->second;
 }
 
-void RenderWidgetHostViewMac::UpdatePluginGeometry(
-    gfx::PluginWindowHandle window,
-    int32 width,
-    int32 height) {
-  if (plugin_container_manager_.IsRootContainer(window)) {
-    // Fake up a WebPluginGeometry for the root window to set the
-    // container's size; we will never get a notification from the
-    // browser about the root window, only plugins.
-    webkit::npapi::WebPluginGeometry geom;
-    gfx::Rect rect(0, 0, width, height);
-    geom.window = window;
-    geom.window_rect = rect;
-    geom.clip_rect = rect;
-    geom.visible = true;
-    geom.rects_valid = true;
-    MovePluginWindows(std::vector<webkit::npapi::WebPluginGeometry>(1, geom));
-  }
-}
-
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetIOSurface(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     uint64 io_surface_identifier) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   plugin_container_manager_.SetSizeAndIOSurface(window,
                                                 width,
                                                 height,
                                                 io_surface_identifier);
-  UpdatePluginGeometry(window, width, height);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetTransportDIB(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     TransportDIB::Handle transport_dib) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   plugin_container_manager_.SetSizeAndTransportDIB(window,
                                                    width,
                                                    height,
                                                    transport_dib);
-  UpdatePluginGeometry(window, width, height);
+}
+
+void RenderWidgetHostViewMac::CompositorSwapBuffers(uint64 surface_handle,
+                                                    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_) {
+    [cocoa_view_ addedGLContext];
+    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];
+  } 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));
-  AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
-  DCHECK(view);
-  if (view) {
-    last_frame_was_accelerated_ = (params.window ==
-        plugin_container_manager_.root_container_handle());
-    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.window == compositing_surface_) {
+    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);
 
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+      // 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));
-  AcceleratedPluginView* view = ViewForPluginWindowHandle(params.window);
-  DCHECK(view);
-  if (view) {
-    last_frame_was_accelerated_ = (params.window ==
-        plugin_container_manager_.root_container_handle());
-    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.window == compositing_surface_) {
+    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));
 
-  if (params.route_id != 0) {
-    RenderWidgetHostImpl::AcknowledgePostSubBuffer(
-        params.route_id, gpu_host_id);
+      // 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() {
 }
 
-void RenderWidgetHostViewMac::UpdateRootGpuViewVisibility(
-    bool show_gpu_widget) {
-  TRACE_EVENT1("renderer_host",
-      "RenderWidgetHostViewMac::UpdateRootGpuViewVisibility",
-      "show", show_gpu_widget);
-  // Plugins are destroyed on page navigate. The compositor layer on the other
-  // hand is created on demand and then stays alive until its renderer process
-  // dies (usually on cross-domain navigation). Instead, only a flag
-  // |is_accelerated_compositing_active()| is flipped when the compositor output
-  // should be shown/hidden.
-  // Show/hide the view belonging to the compositor here.
-  plugin_container_manager_.set_gpu_rendering_active(show_gpu_widget);
-
-  gfx::PluginWindowHandle root_handle =
-      plugin_container_manager_.root_container_handle();
-  if (root_handle != gfx::kNullPluginWindow) {
-    AcceleratedPluginView* view = ViewForPluginWindowHandle(root_handle);
-    DCHECK(view);
-    bool visible =
-        plugin_container_manager_.SurfaceShouldBeVisible(root_handle);
-    [[view window] disableScreenUpdatesUntilFlush];
-    [view setHidden:!visible];
-  }
-}
-
-void RenderWidgetHostViewMac::HandleDelayedGpuViewHiding() {
-  TRACE_EVENT0("renderer_host",
-      "RenderWidgetHostViewMac::HandleDelayedGpuViewHiding");
-  if (needs_gpu_visibility_update_after_repaint_) {
-    UpdateRootGpuViewVisibility(false);
-    needs_gpu_visibility_update_after_repaint_ = false;
-  }
-}
-
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  bool activated = RenderWidgetHostImpl::From(
-      GetRenderWidgetHost())->is_accelerated_compositing_active();
-  bool changed = accelerated_compositing_active_ != activated;
-  accelerated_compositing_active_ = activated;
-  if (!changed)
-    return;
-
-  TRACE_EVENT1("renderer_host",
-      "RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange",
-      "active", accelerated_compositing_active_);
-  if (accelerated_compositing_active_) {
-    UpdateRootGpuViewVisibility(accelerated_compositing_active_);
-  } else {
-    needs_gpu_visibility_update_after_repaint_ = true;
-  }
 }
 
 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() {
-  if (compositing_surface_ == gfx::kNullPluginWindow)
-    compositing_surface_ = AllocateFakePluginWindowHandle(
-        /*opaque=*/true, /*root=*/true);
+  // compositing_surface_ is always gfx::kNullPluginWindow.
   return gfx::GLSurfaceHandle(compositing_surface_, true);
 }
 
 void RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance(
       CGLContextObj context,
       gfx::PluginWindowHandle plugin_handle,
       NSSize size) {
   TRACE_EVENT0("browser",
       "RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstance");
   // Called on the display link thread.
@@ skipping 145 matching lines @@
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super initWithFrame:NSZeroRect];
   if (self) {
     editCommand_helper_.reset(new RenderWidgetHostViewMacEditCommandHelper);
     editCommand_helper_->AddEditingSelectorsToClass([self class]);
 
     renderWidgetHostView_.reset(r);
     canBeKeyView_ = YES;
     focusedPluginIdentifier_ = -1;
+
+    // OpenGL support:
+    handlingGlobalFrameDidChange_ = NO;
+    hasGLContext_ = NO;
+    [[NSNotificationCenter defaultCenter]
+         addObserver:self
+            selector:@selector(globalFrameDidChange:)
+                name:NSViewGlobalFrameDidChangeNotification
+              object:self];
   }
   return self;
 }
 
 - (void)dealloc {
   if (delegate_ && [delegate_ respondsToSelector:@selector(viewGone:)])
     [delegate_ viewGone:self];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   [super dealloc];
 }
 
 - (void)setRWHVDelegate:(NSObject<RenderWidgetHostViewMacDelegate>*)delegate {
   delegate_ = delegate;
 }
 
 - (void)gotUnhandledWheelEvent {
   if (delegate_ &&
@@ skipping 503 matching lines @@
     for (NSView* subview in [self subviews]) {
       if (![subview isKindOfClass:[RenderWidgetHostViewCocoa class]])
         continue;  // Skip plugin views.
 
       [static_cast<RenderWidgetHostViewCocoa*>(subview)
           renderWidgetHostViewMac]->KillSelf();
     }
   }
 }
 
+// OpenGL support
+- (void)addedGLContext {
+  hasGLContext_ = YES;
+  if (![self isHiddenOrHasHiddenAncestor]) {
+    // Intentionally leak underlaySurface count so that the window never changes
+    // back to opaque. This is to prevent black/transparent flashing that
+    // appears during tab switching otherwise.
+    // TODO(jbates) Remove the underlaySurfaceAdded feature completely from
+    // ChromeBrowserWindow when the subtle gray line corner bug is fixed. Then
+    // the window can be permanently set to non-opaque. crbug.com/56154
+    if ([[self window] respondsToSelector:@selector(underlaySurfaceAdded)])
+      [static_cast<id>([self window]) underlaySurfaceAdded];
+  }
+}
+
+- (void)viewWillMoveToWindow:(NSWindow*)newWindow {
+  if (![self isHiddenOrHasHiddenAncestor]) {
+    // Intentionally leak underlaySurface count (see comment in addedGLContext).
+    if (hasGLContext_ &&
+        [newWindow respondsToSelector:@selector(underlaySurfaceAdded)])
+      [static_cast<id>(newWindow) underlaySurfaceAdded];
+  }
+
+  // We're messing with the window, so do this to ensure no flashes. This one
+  // prevents a flash when the current tab is closed.
+  [[self window] disableScreenUpdatesUntilFlush];
+}
+
+- (void) globalFrameDidChange:(NSNotification*)notification {

[Nico, 2012/04/06 16:01:24]

no space after )

+  if (handlingGlobalFrameDidChange_)
+    return;
+
+  handlingGlobalFrameDidChange_ = YES;
+  if (renderWidgetHostView_->compositing_iosurface_.get())
+    renderWidgetHostView_->compositing_iosurface_->GlobalFrameDidChange();
+  handlingGlobalFrameDidChange_ = NO;
+}
+
 - (void)setFrameSize:(NSSize)newSize {
   // NB: -[NSView setFrame:] calls through -setFrameSize:, so overriding
   // -setFrame: isn't neccessary.
   [super setFrameSize:newSize];
   if (renderWidgetHostView_->render_widget_host_)
     renderWidgetHostView_->render_widget_host_->WasResized();
 }
 
 - (void)callSetNeedsDisplayInRect {
   DCHECK([NSThread isMainThread]);
   DCHECK(renderWidgetHostView_->call_set_needs_display_in_rect_pending_);
   [self setNeedsDisplayInRect:renderWidgetHostView_->invalid_rect_];
   renderWidgetHostView_->call_set_needs_display_in_rect_pending_ = false;
   renderWidgetHostView_->invalid_rect_ = NSZeroRect;
-
-  renderWidgetHostView_->HandleDelayedGpuViewHiding();
 }
 
 // Fills with white the parts of the area to the right and bottom for |rect|
 // that intersect |damagedRect|.
 - (void)fillBottomRightRemainderOfRect:(gfx::Rect)rect
                              dirtyRect:(gfx::Rect)damagedRect {
   if (damagedRect.right() > rect.right()) {
     int x = std::max(rect.right(), damagedRect.x());
     int y = std::min(rect.bottom(), damagedRect.bottom());
     int width = damagedRect.right() - x;
@@ skipping 41 matching lines @@
   if (!renderWidgetHostView_->render_widget_host_) {
     // TODO(shess): Consider using something more noticable?
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     return;
   }
 
   const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
 
   if (renderWidgetHostView_->last_frame_was_accelerated_) {
-    gfx::Rect gpuRect;
+    // Draw transparency to expose the GL underlay:
+    // TODO(jbates) avoid doing this every frame.
+    [[NSColor clearColor] set];
+    NSRectFill(dirtyRect);
 
-    gfx::PluginWindowHandle root_handle =
-       renderWidgetHostView_->plugin_container_manager_.root_container_handle();
-    if (root_handle != gfx::kNullPluginWindow) {
-      AcceleratedPluginView* view =
-          renderWidgetHostView_->ViewForPluginWindowHandle(root_handle);
-      DCHECK(view);
-      if (view && ![view isHidden]) {
-        gpuRect = [self flipNSRectToRect:[view frame]];
-      }
-    }
-
-    [self fillBottomRightRemainderOfRect:gpuRect dirtyRect:damagedRect];
+    renderWidgetHostView_->compositing_iosurface_->DrawIOSurface(self);
+    renderWidgetHostView_->AckPendingCompositorSwapBuffers();
     return;
   }
 
+  // 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(),
@@ skipping 974 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