Fix handling of Mac accelerated plugin layers across tab switch.

chrome/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2010 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 <QuartzCore/CAOpenGLLayer.h>
 
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 #import "base/chrome_application_mac.h"
 #include "base/histogram.h"
@@ skipping 31 matching lines @@
   if (flags & NSCommandKeyMask) modifiers |= WebInputEvent::MetaKey;
   return modifiers;
 }
 
 @interface RenderWidgetHostViewCocoa (Private)
 + (BOOL)shouldAutohideCursorForEvent:(NSEvent*)event;
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r;
 - (void)keyEvent:(NSEvent *)theEvent wasKeyEquivalent:(BOOL)equiv;
 - (void)cancelChildPopups;
 - (void)callSetNeedsDisplayInRect:(NSValue*)rect;
+- (void)attachPluginLayer;
 @end
 
 namespace {
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 }
 
-// GPUPluginLayer --------------------------------------------------------------
+// AcceleratedPluginLayer ------------------------------------------------------
 
-// This subclass of CAOpenGLLayer hosts the output of the GPU-accelerated
-// plugins on the page.
+// This subclass of CAOpenGLLayer hosts the output of accelerated plugins on
+// the page.
 
-@interface GPUPluginLayer : CAOpenGLLayer {
+@interface AcceleratedPluginLayer : CAOpenGLLayer {
   RenderWidgetHostViewMac* renderWidgetHostView_;  // weak
 }
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r;
 @end
 
-@implementation GPUPluginLayer
+@implementation AcceleratedPluginLayer
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r {
   self = [super init];
   if (self != nil) {
     renderWidgetHostView_ = r;
   }
   return self;
 }
 
--(void)drawInCGLContext:(CGLContextObj)glContext
-       pixelFormat:(CGLPixelFormatObj)pixelFormat
-       forLayerTime:(CFTimeInterval)timeInterval
-       displayTime:(const CVTimeStamp *)timeStamp {
+- (void)drawInCGLContext:(CGLContextObj)glContext
+             pixelFormat:(CGLPixelFormatObj)pixelFormat
+            forLayerTime:(CFTimeInterval)timeInterval
+             displayTime:(const CVTimeStamp *)timeStamp {
   renderWidgetHostView_->DrawAcceleratedSurfaceInstances(glContext);
   [super drawInCGLContext:glContext
               pixelFormat:pixelFormat
              forLayerTime:timeInterval
               displayTime:timeStamp];
 }
+
+- (void)setFrame:(CGRect)rect {
+  // The frame we get when the superlayer resizes doesn't make sense, so ignore
+  // it and just match the superlayer's size. See the email thread referenced in
+  // ensureAcceleratedPluginLayer for an explanation of why the superlayer
+  // isn't trustworthy.
+  if ([self superlayer])
+    [super setFrame:[[self superlayer] bounds]];
+  else
+    [super setFrame:rect];
+}
 @end
 
 // RenderWidgetHostView --------------------------------------------------------
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewMac(widget);
 }
 
@@ skipping 108 matching lines @@
   rect.set_height(size.height());
   [cocoa_view_ setFrame:[(BaseView*)[cocoa_view_ superview] RectToNSRect:rect]];
 }
 
 gfx::NativeView RenderWidgetHostViewMac::GetNativeView() {
   return native_view();
 }
 
 void RenderWidgetHostViewMac::MovePluginWindows(
     const std::vector<webkit_glue::WebPluginGeometry>& moves) {
-  // The only case we need to notice plugin window moves is the case
-  // of the GPU plugin. As soon as the GPU plugin becomes the GPU
-  // process all of this code will go away.
+  // Handle movement of accelerated plugins, which are the only "windowed"
+  // plugins that exist on the Mac.
   if (moves.size() > 0) {
     for (std::vector<webkit_glue::WebPluginGeometry>::const_iterator iter =
              moves.begin();
          iter != moves.end();
          ++iter) {
       webkit_glue::WebPluginGeometry geom = *iter;
       // Ignore bogus moves which claim to move the plugin to (0, 0)
       // with width and height (0, 0)
       if (geom.window_rect.x() != 0 ||
           geom.window_rect.y() != 0 ||
           geom.window_rect.width() != 0 ||
           geom.window_rect.height() != 0) {
         plugin_container_manager_.MovePluginContainer(geom);
       }
     }
   }
-
-  // All plugin stuff is TBD. TODO(avi,awalker): fill in
-  // http://crbug.com/8192
 }
 
 void RenderWidgetHostViewMac::Focus() {
   [[cocoa_view_ window] makeFirstResponder:cocoa_view_];
 }
 
 void RenderWidgetHostViewMac::Blur() {
   [[cocoa_view_ window] makeFirstResponder:nil];
 }
 
@@ skipping 257 matching lines @@
   if (shutdown_factory_.empty()) {
     [cocoa_view_ setHidden:YES];
     MessageLoop::current()->PostTask(FROM_HERE,
         shutdown_factory_.NewRunnableMethod(
             &RenderWidgetHostViewMac::ShutdownHost));
   }
 }
 
 gfx::PluginWindowHandle
 RenderWidgetHostViewMac::AllocateFakePluginWindowHandle() {
-  // If we don't already have a GPUPluginLayer allocated for our view,
-  // set one up now.
-  if (gpu_plugin_layer_.get() == nil) {
-    RenderWidgetHostViewCocoa* our_view = native_view();
-    // Try to get AppKit to allocate the layer
-    [our_view setWantsLayer:YES];
-    CALayer* root_layer = [our_view layer];
-    if (root_layer == nil) {
-      root_layer = [CALayer layer];
-      [our_view setLayer:root_layer];
-    }
-
-    GPUPluginLayer* gpu_layer =
-        [[GPUPluginLayer alloc] initWithRenderWidgetHostViewMac:this];
-
-    // Make our layer resize to fit the superlayer
-    gpu_layer.autoresizingMask = kCALayerWidthSizable | kCALayerHeightSizable;
-    // Set up its initial size
-    [gpu_layer setFrame:NSRectToCGRect([our_view bounds])];
-
-    [root_layer addSublayer:gpu_layer];
-    gpu_plugin_layer_.reset(gpu_layer);
-  }
+  // Make sure we have a layer for the plugin to draw into.
+  [cocoa_view_ ensureAcceleratedPluginLayer];
 
   return plugin_container_manager_.AllocateFakePluginWindowHandle();
 }
 
 void RenderWidgetHostViewMac::DestroyFakePluginWindowHandle(
     gfx::PluginWindowHandle window) {
   plugin_container_manager_.DestroyFakePluginWindowHandle(window);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetIOSurface(
@@ skipping 13 matching lines @@
     int32 height,
     TransportDIB::Handle transport_dib) {
   plugin_container_manager_.SetSizeAndTransportDIB(window,
                                                    width,
                                                    height,
                                                    transport_dib);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     gfx::PluginWindowHandle window) {
-  [gpu_plugin_layer_.get() setNeedsDisplay];
+  [cocoa_view_ drawAcceleratedPluginLayer];
 }
 
 void RenderWidgetHostViewMac::DrawAcceleratedSurfaceInstances(
     CGLContextObj context) {
   CGLSetCurrentContext(context);
   gfx::Rect rect = GetWindowRect();
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   // Note that we place the origin at the upper left corner with +y
   // going down
   glOrtho(0, rect.width(), rect.height(), 0, -1, 1);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
 
   plugin_container_manager_.Draw(context);
 }
 
+void RenderWidgetHostViewMac::AcceleratedSurfaceContextChanged() {
+  plugin_container_manager_.ForceTextureReload();
+}
+
 void RenderWidgetHostViewMac::SetVisuallyDeemphasized(bool deemphasized) {
   // Mac uses tab-modal sheets, so this is a no-op.
 }
 
 void RenderWidgetHostViewMac::ShutdownHost() {
   shutdown_factory_.RevokeAll();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
@@ skipping 451 matching lines @@
       // recorded.
       renderWidgetHostView_->tab_switch_paint_time_ = base::TimeTicks();
     }
   } else {
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     if (renderWidgetHostView_->whiteout_start_time_.is_null())
       renderWidgetHostView_->whiteout_start_time_ = base::TimeTicks::Now();
   }
 
-  // This helps keep the GPU plugins' output in better sync with the
+  // This helps keep accelerated plugins' output in better sync with the
   // window as it resizes.
-  [renderWidgetHostView_->gpu_plugin_layer_.get() setNeedsDisplay];
+  [accelerated_plugin_layer_.get() setNeedsDisplay];
 }
 
 - (BOOL)canBecomeKeyView {
   if (!renderWidgetHostView_->render_widget_host_)
     return NO;
 
   return canBeKeyView_;
 }
 
 - (BOOL)acceptsFirstResponder {
@@ skipping 594 matching lines @@
   }
 }
 
 - (void)pasteAsPlainText:(id)sender {
   if (renderWidgetHostView_->render_widget_host_->IsRenderView()) {
     static_cast<RenderViewHost*>(renderWidgetHostView_->render_widget_host_)->
       ForwardEditCommand("PasteAndMatchStyle", "");
   }
 }
 
+- (void)ensureAcceleratedPluginLayer {
+  if (accelerated_plugin_layer_.get())
+    return;
+
+  AcceleratedPluginLayer* plugin_layer = [[AcceleratedPluginLayer alloc]

[pink (ping after 24hrs), 2010/03/23 17:32:04]

objC should use objC naming: pluginLayer, etc.

+      initWithRenderWidgetHostViewMac:renderWidgetHostView_.get()];
+  accelerated_plugin_layer_.reset(plugin_layer);
+  // Make our layer resize to fit the superlayer
+  plugin_layer.autoresizingMask = kCALayerWidthSizable |
+                                  kCALayerHeightSizable;
+  // Make the view layer-backed so that there will be a layer to hang the
+  // |layer| off of. This is not the "right" way to host a sublayer in a view,
+  // but the right way would require making the whole view's drawing system
+  // layer-based (using setLayer:). We don't want to do that (at least not
+  // yet) so instead we override setLayer: and re-bind our plugin layer each
+  // time the view's layer changes. For discussion see:
+  // http://lists.apple.com/archives/Cocoa-dev/2009/Feb/msg01132.html
+  [self setWantsLayer:YES];
+  [self attachPluginLayer];
+}
+
+- (void)attachPluginLayer {
+  CALayer* plugin_layer = accelerated_plugin_layer_.get();
+  if (!plugin_layer)
+    return;
+
+  CALayer* root_layer = [self layer];
+  DCHECK(root_layer != nil);
+  [plugin_layer setFrame:NSRectToCGRect([self bounds])];
+  [root_layer addSublayer:plugin_layer];
+  renderWidgetHostView_->AcceleratedSurfaceContextChanged();
+}
+
+- (void)setLayer:(CALayer *)newLayer {
+  CALayer* plugin_layer = accelerated_plugin_layer_.get();
+  if (!newLayer && [plugin_layer superlayer])
+    [plugin_layer removeFromSuperlayer];
+
+  [super setLayer:newLayer];
+  if ([self layer])
+    [self attachPluginLayer];
+}
+
+- (void)drawAcceleratedPluginLayer {
+  [accelerated_plugin_layer_.get() setNeedsDisplay];
+}
+
 @end