Mac: Make resizing the window larger nicer when compositor is active

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/QuartzCore.h>
 
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 #include "chrome/browser/chrome_thread.h"
 #include "app/surface/io_surface_support_mac.h"
@@ skipping 943 matching lines @@
   shutdown_factory_.RevokeAll();
   render_widget_host_->Shutdown();
   // Do not touch any members at this point, |this| has been deleted.
 }
 
 namespace {
 
 // Adjusts an NSRect in Cocoa screen coordinates to have an origin in the upper
 // left of the primary screen (Carbon coordinates), and stuffs it into a
 // gfx::Rect.
-gfx::Rect flipNSRectToRect(const NSRect rect) {
+gfx::Rect FlipNSRectToRectScreen(const NSRect rect) {
   gfx::Rect new_rect(NSRectToCGRect(rect));
   if ([[NSScreen screens] count] > 0) {
     new_rect.set_y([[[NSScreen screens] objectAtIndex:0] frame].size.height -
                    new_rect.y() - new_rect.height());
   }
   return new_rect;
 }
 
 // Returns the window that visually contains the given view. This is different
 // from [view window] in the case of tab dragging, where the view's owning
@@ skipping 22 matching lines @@
   // 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 = [cocoa_view_ bounds];
   bounds = [cocoa_view_ convertRect:bounds toView:nil];
   bounds.origin = [enclosing_window convertBaseToScreen:bounds.origin];
-  return flipNSRectToRect(bounds);
+  return FlipNSRectToRectScreen(bounds);
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetRootWindowRect() {
   // 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 flipNSRectToRect(bounds);
+  return FlipNSRectToRectScreen(bounds);
 }
 
 void RenderWidgetHostViewMac::SetActive(bool active) {
   if (render_widget_host_)
     render_widget_host_->SetActive(active);
   if (HasFocus())
     SetTextInputActive(active);
 }
 
 void RenderWidgetHostViewMac::SetWindowVisibility(bool visible) {
@@ skipping 399 matching lines @@
 }
 
 - (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;
 }
 
+// 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;
+    int height = damagedRect.y() - y;
+
+    // Extra fun to get around the fact that gfx::Rects can't have
+    // negative sizes.
+    if (width < 0) {
+      x += width;
+      width = -width;
+    }
+    if (height < 0) {
+      y += height;
+      height = -height;
+    }
+
+    NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
+    [[NSColor whiteColor] set];
+    NSRectFill(r);
+  }
+  if (damagedRect.bottom() > rect.bottom()) {
+    int x = damagedRect.x();
+    int y = damagedRect.bottom();
+    int width = damagedRect.right() - x;
+    int height = std::max(rect.bottom(), damagedRect.y()) - y;
+
+    // Extra fun to get around the fact that gfx::Rects can't have
+    // negative sizes.
+    if (width < 0) {
+      x += width;
+      width = -width;
+    }
+    if (height < 0) {
+      y += height;
+      height = -height;
+    }
+
+    NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
+    [[NSColor whiteColor] set];
+    NSRectFill(r);
+  }
+}
+
 - (void)drawRect:(NSRect)dirtyRect {
   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_->render_widget_host_->is_gpu_rendering_active()) {
+    gfx::Rect gpuRect;
+
+    gfx::PluginWindowHandle root_handle =
+       renderWidgetHostView_->plugin_container_manager_.root_container_handle();
+    if (root_handle != gfx::kNullPluginWindow) {
+      RenderWidgetHostViewMac::PluginViewMap::iterator it =
+          renderWidgetHostView_->plugin_views_.find(root_handle);
+      DCHECK(it != renderWidgetHostView_->plugin_views_.end());
+      if (it != renderWidgetHostView_->plugin_views_.end() &&
+          ![it->second isHidden]) {
+        gpuRect = [self flipNSRectToRect:[it->second frame]];
+      }
+    }
+
+    [self fillBottomRightRemainderOfRect:gpuRect dirtyRect:damagedRect];
     return;
   }
 
   DCHECK(
       renderWidgetHostView_->render_widget_host_->process()->HasConnection());
   DCHECK(!renderWidgetHostView_->about_to_validate_and_paint_);
 
   renderWidgetHostView_->about_to_validate_and_paint_ = true;
-  BackingStoreMac* backing_store = static_cast<BackingStoreMac*>(
+  BackingStoreMac* backingStore = static_cast<BackingStoreMac*>(
       renderWidgetHostView_->render_widget_host_->GetBackingStore(true));
   renderWidgetHostView_->about_to_validate_and_paint_ = false;
 
-  if (backing_store) {
-    NSRect view_bounds = [self bounds];
-    gfx::Rect damaged_rect([self flipNSRectToRect:dirtyRect]);
-
-    gfx::Rect bitmap_rect(0, 0,
-                          backing_store->size().width(),
-                          backing_store->size().height());
+  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(view_bounds) - backing_store->size().height();
+    int yOffset = NSHeight([self bounds]) - backingStore->size().height();
 
-    gfx::Rect paint_rect = bitmap_rect.Intersect(damaged_rect);
-    if (!paint_rect.IsEmpty()) {
+    gfx::Rect paintRect = bitmapRect.Intersect(damagedRect);
+    if (!paintRect.IsEmpty()) {
       // if we have a CGLayer, draw that into the window
-      if (backing_store->cg_layer()) {
+      if (backingStore->cg_layer()) {
         CGContextRef context = static_cast<CGContextRef>(
             [[NSGraphicsContext currentContext] graphicsPort]);
 
         // TODO: add clipping to dirtyRect if it improves drawing performance.
         CGContextDrawLayerAtPoint(context, CGPointMake(0.0, yOffset),
-                                  backing_store->cg_layer());
+                                  backingStore->cg_layer());
       } else {
         // if we haven't created a layer yet, draw the cached bitmap into
         // the window.  The CGLayer will be created the next time the renderer
         // paints.
         CGContextRef context = static_cast<CGContextRef>(
             [[NSGraphicsContext currentContext] graphicsPort]);
         scoped_cftyperef<CGImageRef> image(
-            CGBitmapContextCreateImage(backing_store->cg_bitmap()));
-        CGRect imageRect = bitmap_rect.ToCGRect();
+            CGBitmapContextCreateImage(backingStore->cg_bitmap()));
+        CGRect imageRect = bitmapRect.ToCGRect();
         imageRect.origin.y = yOffset;
         CGContextDrawImage(context, imageRect, image);
       }
     }
 
-    // Fill the remaining portion of the damaged_rect with white
-    if (damaged_rect.right() > bitmap_rect.right()) {
-      int x = std::max(bitmap_rect.right(), damaged_rect.x());
-      int y = std::min(bitmap_rect.bottom(), damaged_rect.bottom());
-      int width = damaged_rect.right() - x;
-      int height = damaged_rect.y() - y;
+    // Fill the remaining portion of the damagedRect with white
+    [self fillBottomRightRemainderOfRect:bitmapRect dirtyRect:damagedRect];
 
-      // Extra fun to get around the fact that gfx::Rects can't have
-      // negative sizes.
-      if (width < 0) {
-        x += width;
-        width = -width;
-      }
-      if (height < 0) {
-        y += height;
-        height = -height;
-      }
-
-      NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
-      [[NSColor whiteColor] set];
-      NSRectFill(r);
-    }
-    if (damaged_rect.bottom() > bitmap_rect.bottom()) {
-      int x = damaged_rect.x();
-      int y = damaged_rect.bottom();
-      int width = damaged_rect.right() - x;
-      int height = std::max(bitmap_rect.bottom(), damaged_rect.y()) - y;
-
-      // Extra fun to get around the fact that gfx::Rects can't have
-      // negative sizes.
-      if (width < 0) {
-        x += width;
-        width = -width;
-      }
-      if (height < 0) {
-        y += height;
-        height = -height;
-      }
-
-      NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
-      [[NSColor whiteColor] set];
-      NSRectFill(r);
-    }
     if (!renderWidgetHostView_->whiteout_start_time_.is_null()) {
       base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
           renderWidgetHostView_->whiteout_start_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
 
       // Reset the start time to 0 so that we start recording again the next
       // time the backing store is NULL...
       renderWidgetHostView_->whiteout_start_time_ = base::TimeTicks();
     }
     if (!renderWidgetHostView_->tab_switch_paint_time_.is_null()) {
@@ skipping 837 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