Stretching NativeViewHost, and misc tab capture fixes.

chrome/browser/ui/cocoa/tab_contents/tab_contents_controller.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.
 
 #import "chrome/browser/ui/cocoa/tab_contents/tab_contents_controller.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #import "chrome/browser/themes/theme_properties.h"
 #import "chrome/browser/themes/theme_service.h"
 #import "chrome/browser/ui/cocoa/themed_window.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "skia/ext/skia_utils_mac.h"
 #include "ui/base/cocoa/animation_utils.h"
-#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_f.h"
 
 using content::WebContents;
 using content::WebContentsObserver;
 
 // FullscreenObserver is used by TabContentsController to monitor for the
 // showing/destruction of fullscreen render widgets.  When notified,
 // TabContentsController will alter its child view hierarchy to either embed a
 // fullscreen render widget view or restore the normal WebContentsView render
 // view.  The embedded fullscreen render widget will fill the user's screen in
 // the case where TabContentsController's NSView is a subview of a browser
@@ skipping 26 matching lines @@
   }
 
  private:
   TabContentsController* const controller_;
 
   DISALLOW_COPY_AND_ASSIGN(FullscreenObserver);
 };
 
 @interface TabContentsController (TabContentsContainerViewDelegate)
 - (BOOL)contentsInFullscreenCaptureMode;
-// Computes and returns the frame to use for the contents view using the size of
-// |container| as the target size.
-- (NSRect)frameForContentsViewIn:(NSView*)container;
+
+// Computes and returns the frame to use for the scaling view within the
+// TabContentsContainerView.
+- (NSRect)frameForScalingViewIn:(NSView*)container;
+
+// Computes and returns the bounds to use for the scaling view within the
+// TabContentsContainerView. In the normal case, the bounds size will be
+// equivalent to frame size. In 'AutoEmbedFullscreen mode', the bounds size is
+// set to the video capture resolution, which is almost always different from
+// the frame size. See 'AutoEmbedFullscreen mode' in header file comments.
+- (NSRect)boundsForScalingViewIn:(NSView*)container;
 
 // Returns YES if the content view should be resized.
 - (BOOL)shouldResizeContentView;
 
 // Returns YES if the content view is inside a popup.
 - (BOOL)isPopup;
 
 @end
 
 // An NSView with special-case handling for when the contents view does not
 // expand to fill the entire tab contents area. See 'AutoEmbedFullscreen mode'
 // in header file comments.
+//
+// This view creates and manages its own subview, a "scaling" view, which acts
+// as a container for the contents view. It allows the rendering size of the
+// contents view to be something different than its normal on-screen display
+// size.
 @interface TabContentsContainerView : NSView {
  @private
   TabContentsController* delegate_;  // weak
 }
 
+- (void)ensureContentsVisible:(NSView*)contentsView;
 - (void)updateBackgroundColor;
 @end
 
 @implementation TabContentsContainerView
 
 - (id)initWithDelegate:(TabContentsController*)delegate {
   if ((self = [super initWithFrame:NSZeroRect])) {
     delegate_ = delegate;
+
     ScopedCAActionDisabler disabler;
     base::scoped_nsobject<CALayer> layer([[CALayer alloc] init]);
     [self setLayer:layer];
     [self setWantsLayer:YES];
     [self updateBackgroundColor];
+
+    // Create and add the scaling view.
+    [self addSubview:[[NSView alloc] initWithFrame:NSZeroRect]];
   }
   return self;
 }
 
 // Called by the delegate during dealloc to invalidate the pointer held by this
 // view.
 - (void)delegateDestroyed {
   delegate_ = nil;
 }
 
-// Override auto-resizing logic to query the delegate for the exact frame to
-// use for the contents view.
-// TODO(spqchan): The popup check is a temporary solution to fix the regression
-// issue described in crbug.com/604288. This method doesn't really affect
-// fullscreen if the content is inside a normal browser window, but would
-// cause a flash fullscreen widget to blow up if it's inside a popup.
+// Returns the scaling view, which is the child of TabContentsContainerView.
+- (NSView*)scalingView {
+  return [[self subviews] objectAtIndex:0];
+}
+
+// Return the contents view, which is the child of the scaling view; or nil if
+// there isn't one attached.
+- (NSView*)contentsView {
+  NSArray* const scalingViewSubviews = [[self scalingView] subviews];
+  if ([scalingViewSubviews count] == 0)
+    return nil;  // No contents view attached.
+  return [scalingViewSubviews objectAtIndex:0];
+}
+
+// Override auto-resizing logic to query the delegate for the exact frame and
+// bounds to use for the contents view, and then perform manual layout of the
+// scaling view (child view) and contents view (grandchild view).
 - (void)resizeSubviewsWithOldSize:(NSSize)oldBoundsSize {
-  NSView* const contentsView =
-      [[self subviews] count] > 0 ? [[self subviews] objectAtIndex:0] : nil;
-  if (!contentsView || [contentsView autoresizingMask] == NSViewNotSizable ||
-      !delegate_ ||
+  ScopedCAActionDisabler disabler;
+
+  NSView* const contentsView = [self contentsView];
+  if (!contentsView)
+    return;  // No contents view attached yet.
+
+  // TODO(spqchan): The popup check is a temporary solution to fix the
+  // regression described in crbug.com/604288. This method doesn't really affect
+  // fullscreen if the content is inside a normal browser window, but would
+  // cause a flash fullscreen widget to blow up if it's inside a popup.
+  if (!delegate_ ||
       (![delegate_ shouldResizeContentView] && [delegate_ isPopup])) {
     return;
   }
 
-  ScopedCAActionDisabler disabler;
-  [contentsView setFrame:[delegate_ frameForContentsViewIn:self]];
+  // Set the position and size of the scaling view within this container view.
+  NSView* const scalingView = [self scalingView];
+  [scalingView setFrame:[delegate_ frameForScalingViewIn:self]];
+  const NSRect scalingViewBounds = [delegate_ boundsForScalingViewIn:self];
+  [scalingView setBounds:scalingViewBounds];
+
+  // Update the position and size of the contents view, if it has changed.
+  if (!NSEqualRects(scalingViewBounds, [contentsView frame]))
+    [contentsView setFrame:scalingViewBounds];
 }
 
 // Update the background layer's color whenever the view needs to repaint.
 - (void)setNeedsDisplayInRect:(NSRect)rect {
   [super setNeedsDisplayInRect:rect];
   [self updateBackgroundColor];
 }
 
+- (void)ensureContentsVisible:(NSView*)contentsView {
+  DCHECK(contentsView);
+
+  // TabContentsContainerView performs manual layout.
+  [contentsView setAutoresizingMask:NSViewNotSizable];
+
+  NSView* const scalingView = [self scalingView];
+  if ([[scalingView subviews] count] == 0) {
+    [scalingView addSubview:contentsView];
+  } else if ([[scalingView subviews] objectAtIndex:0] != contentsView) {
+    [scalingView replaceSubview:[[scalingView subviews] objectAtIndex:0]
+                           with:contentsView];
+  }
+
+  [self resizeSubviewsWithOldSize:[self bounds].size];
+}
+
 - (void)updateBackgroundColor {
   // This view is sometimes flashed into visibility (e.g, when closing
   // windows or opening new tabs), so ensure that the flash be the theme
   // background color in those cases.
   SkColor skBackgroundColor = SK_ColorWHITE;
   const ThemeProvider* theme = [[self window] themeProvider];
   if (theme)
     skBackgroundColor = theme->GetColor(ThemeProperties::COLOR_NTP_BACKGROUND);
 
   // If the page is in fullscreen tab capture mode, change the background color
@@ skipping 11 matching lines @@
   base::ScopedCFTypeRef<CGColorRef> cgBackgroundColor(
       skia::CGColorCreateFromSkColor(skBackgroundColor));
   [[self layer] setBackgroundColor:cgBackgroundColor];
 }
 
 - (ViewID)viewID {
   return VIEW_ID_TAB_CONTAINER;
 }
 
 - (BOOL)acceptsFirstResponder {
-  return [[self subviews] count] > 0 &&
-      [[[self subviews] objectAtIndex:0] acceptsFirstResponder];
+  NSView* const contentsView = [self contentsView];
+  return contentsView && [contentsView acceptsFirstResponder];
 }
 
 // When receiving a click-to-focus in the solid color area surrounding the
 // WebContents' native view, immediately transfer focus to WebContents' native
 // view.
 - (BOOL)becomeFirstResponder {
   if (![self acceptsFirstResponder])
     return NO;
-  return [[self window] makeFirstResponder:[[self subviews] objectAtIndex:0]];
+  return [[self window] makeFirstResponder:[self contentsView]];
 }
 
 - (BOOL)canBecomeKeyView {
   return NO;  // Tab/Shift-Tab should focus the subview, not this view.
 }
 
 @end  // @implementation TabContentsContainerView
 
 @implementation TabContentsController
 @synthesize webContents = contents_;
@@ skipping 21 matching lines @@
       [[TabContentsContainerView alloc] initWithDelegate:self]);
   [view setAutoresizingMask:NSViewHeightSizable|NSViewWidthSizable];
   [self setView:view];
 }
 
 - (void)ensureContentsVisibleInSuperview:(NSView*)superview {
   if (!contents_)
     return;
 
   ScopedCAActionDisabler disabler;
-  NSView* contentsContainer = [self view];
-  NSArray* subviews = [contentsContainer subviews];
+
   NSView* contentsNativeView;
   content::RenderWidgetHostView* const fullscreenView =
       isEmbeddingFullscreenWidget_ ?
       contents_->GetFullscreenRenderWidgetHostView() : NULL;
   if (fullscreenView) {
     contentsNativeView = fullscreenView->GetNativeView();
   } else {
     isEmbeddingFullscreenWidget_ = NO;
     contentsNativeView = contents_->GetNativeView();
   }
 
-  if ([self shouldResizeContentView])
-    [contentsNativeView setFrame:[self frameForContentsViewIn:superview]];
-
-  if ([subviews count] == 0) {
-    [contentsContainer addSubview:contentsNativeView];
-  } else if ([subviews objectAtIndex:0] != contentsNativeView) {
-    [contentsContainer replaceSubview:[subviews objectAtIndex:0]
-                                 with:contentsNativeView];
-  }
-
-  [contentsNativeView setAutoresizingMask:NSViewNotSizable];
+  TabContentsContainerView* const contentsContainer =
+      static_cast<TabContentsContainerView*>([self view]);
+  [contentsContainer ensureContentsVisible:contentsNativeView];
   [contentsContainer setFrame:[superview bounds]];
   [superview addSubview:contentsContainer];
-  [contentsNativeView setAutoresizingMask:NSViewWidthSizable|
-                                          NSViewHeightSizable];
-
   [contentsContainer setNeedsDisplay:YES];
 
   // Push the background color down to the RenderWidgetHostView, so that if
   // there is a flash between contents appearing, it will be the theme's color,
   // not white.
   SkColor skBackgroundColor = SK_ColorWHITE;
   const ThemeProvider* theme = [[[self view] window] themeProvider];
   if (theme)
     skBackgroundColor = theme->GetColor(ThemeProperties::COLOR_NTP_BACKGROUND);
   content::RenderWidgetHostView* rwhv = contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetBackgroundColor(skBackgroundColor);
 }
 
 - (void)updateFullscreenWidgetFrame {
   // This should only apply if a fullscreen widget is embedded.
   if (!isEmbeddingFullscreenWidget_ || blockFullscreenResize_)
     return;
 
   content::RenderWidgetHostView* const fullscreenView =
       contents_->GetFullscreenRenderWidgetHostView();
   if (fullscreenView) {
-    [fullscreenView->GetNativeView()
-        setFrame:[self frameForContentsViewIn:[self view]]];
+    [static_cast<TabContentsContainerView*>([self view])
+        ensureContentsVisible:fullscreenView->GetNativeView()];
   }
 }
 
 - (void)changeWebContents:(WebContents*)newContents {
   contents_ = newContents;
   fullscreenObserver_->Observe(contents_);
   isEmbeddingFullscreenWidget_ =
       contents_ && contents_->GetFullscreenRenderWidgetHostView();
 }
 
@@ skipping 56 matching lines @@
       wc->GetCapturerCount() == 0 ||
       wc->GetPreferredSize().IsEmpty() ||
       !(isEmbeddingFullscreenWidget_ ||
         (wc->GetDelegate() &&
          wc->GetDelegate()->IsFullscreenForTabOrPending(wc)))) {
     return NO;
   }
   return YES;
 }
 
-- (NSRect)frameForContentsViewIn:(NSView*)container {
-  gfx::Rect rect([container bounds]);
+- (NSRect)frameForScalingViewIn:(NSView*)container {
+  NSRect bounds = [container bounds];
+  bounds.origin = NSZeroPoint;
 
   // In most cases, the contents view is simply sized to fill the container
   // view's bounds. Only WebContentses that are in fullscreen mode and being
   // screen-captured will engage the special layout/sizing behavior.
   if (![self contentsInFullscreenCaptureMode])
-    return NSRectFromCGRect(rect.ToCGRect());
+    return bounds;
 
-  // Size the contents view to the capture video resolution and center it. If
-  // the container view is not large enough to fit it at the preferred size,
-  // scale down to fit (preserving aspect ratio).
-  content::WebContents* const wc = fullscreenObserver_->web_contents();
-  const gfx::Size captureSize = wc->GetPreferredSize();
-  if (captureSize.width() <= rect.width() &&
-      captureSize.height() <= rect.height()) {
-    // No scaling, just centering.
-    rect.ClampToCenteredSize(captureSize);
+  // For 'AutoEmbedFullscreen mode', scale the view to fit within the container,
+  // and center it.
+  gfx::RectF rect(bounds);
+  gfx::Size captureSize =
+      fullscreenObserver_->web_contents()->GetPreferredSize();
+  DCHECK(!captureSize.IsEmpty());
+  const float x = captureSize.width() * rect.height();
+  const float y = captureSize.height() * rect.width();
+  if (y < x) {
+    rect.ClampToCenteredSize(gfx::SizeF(rect.width(), y / captureSize.width()));
   } else {
-    // Scale down, preserving aspect ratio, and center.
-    // TODO(miu): This is basically media::ComputeLetterboxRegion(), and it
-    // looks like others have written this code elsewhere.  Let's consolidate
-    // into a shared function ui/gfx/geometry or around there.
-    const int64_t x = static_cast<int64_t>(captureSize.width()) * rect.height();
-    const int64_t y = static_cast<int64_t>(captureSize.height()) * rect.width();
-    if (y < x) {
-      rect.ClampToCenteredSize(gfx::Size(
-          rect.width(), static_cast<int>(y / captureSize.width())));
-    } else {
-      rect.ClampToCenteredSize(gfx::Size(
-          static_cast<int>(x / captureSize.height()), rect.height()));
-    }
+    rect.ClampToCenteredSize(
+        gfx::SizeF(x / captureSize.height(), rect.height()));
   }
+  // Ensure the bounds align with pixel boundaries.
+  return gfx::ToEnclosedRect(rect).ToCGRect();
+}
 
-  return NSRectFromCGRect(rect.ToCGRect());
+- (NSRect)boundsForScalingViewIn:(NSView*)container {
+  NSRect bounds;
+  bounds.origin = NSZeroPoint;
+
+  // When in 'AutoEmbedFullscreen mode' mode, the bounds size is set to the
+  // video capture resolution. See header file for more details.
+  if ([self contentsInFullscreenCaptureMode]) {
+    content::WebContents* const wc = fullscreenObserver_->web_contents();
+    gfx::Size captureSize = wc->GetPreferredSize();
+    DCHECK(!captureSize.IsEmpty());
+    bounds.size = captureSize.ToCGSize();
+  } else {
+    bounds.size = [container bounds].size;
+  }
+  return bounds;
 }
 
 - (BOOL)shouldResizeContentView {
   return !isEmbeddingFullscreenWidget_ || !blockFullscreenResize_;
 }
 
 - (BOOL)isPopup {
   return isPopup_;
 }
 
 @end