mac: Use a full-size content view (reland 1).

chrome/browser/ui/cocoa/browser_window_controller_browsertest.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/browser_window_controller.h"
 
 #import "base/mac/mac_util.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 205 matching lines @@
     NSPoint icon_bottom = location_bar_view->GetPageInfoBubblePoint();
 
     NSPoint info_bar_top = NSMakePoint(0,
         NSHeight([info_bar_container_controller view].frame) -
         overlapping_tip_height);
     info_bar_top = [[info_bar_container_controller view]
         convertPoint:info_bar_top toView:nil];
     return icon_bottom.y - info_bar_top.y;
   }
 
-  // The traffic lights should always be in front of the content view and the
-  // tab strip view. Since the traffic lights change across OSX versions, this
-  // test verifies that the contentView is in the back, and if the tab strip
-  // view is a sibling, it is directly in front of the content view.
-  void VerifyTrafficLightZOrder() const {
-    NSView* contentView = [[controller() window] contentView];
-    NSView* rootView = [contentView superview];
-    NSArray* subviews = [rootView subviews];
+  // Checks that |view| does not draw on top of |exposedView_|.
+  void CheckViewDoesNotObscure(NSView* view) {
+    NSRect viewWindowFrame = [view convertRect:[view bounds] toView:nil];
+    NSRect viewBeingVerifiedWindowFrame =
+        [exposedView_ convertRect:[exposedView_ bounds] toView:nil];
 
-    EXPECT_EQ([controller() tabStripBackgroundView],
-              [subviews objectAtIndex:0]);
-    EXPECT_EQ(contentView, [subviews objectAtIndex:1]);
+    // The views do not intersect.
+    if (!NSIntersectsRect(viewBeingVerifiedWindowFrame, viewWindowFrame))
+      return;
 
-    NSView* tabStripView = [controller() tabStripView];
-    if ([subviews containsObject:tabStripView])
-      EXPECT_EQ(tabStripView, [subviews objectAtIndex:2]);
+    // No view can be above the view being checked.
+    EXPECT_TRUE(belowExposedView_);
+
+    // If |view| is a parent of |exposedView_|, then there's nothing else
+    // to check.
+    NSView* parent = exposedView_;
+    while (parent != nil) {
+      parent = [parent superview];
+      if (parent == view)
+        return;
+    }
+
+    if ([exposedView_ layer])
+      return;
+
+    // If the view being verified doesn't have a layer, then no views that
+    // intersect it can have a layer. The exceptions are the contentView,
+    // chromeContentView and tabStripView, which are layer backed but
+    // transparent.
+    NSArray* exceptions = @[
+      [[view window] contentView],
+      controller().chromeContentView,
+      controller().tabStripView
+    ];
+    if ([exceptions containsObject:view]) {
+      EXPECT_FALSE([view isOpaque]);
+      return;
+    }
+
+    EXPECT_TRUE(![view layer]) << [[view description] UTF8String] << " " <<
+        [NSStringFromRect(viewWindowFrame) UTF8String];
+  }
+
+  // Recursively checks that |view| and its subviews do not draw on top of
+  // |exposedView_|. The recursion passes through all views in order of
+  // back-most in Z-order to front-most in Z-order.
+  void CheckViewsDoNotObscure(NSView* view) {
+    // If this is the view being checked, don't recurse into its subviews. All
+    // future views encountered in the recursion are in front of the view being
+    // checked.
+    if (view == exposedView_) {
+      belowExposedView_ = NO;
+      return;
+    }
+
+    CheckViewDoesNotObscure(view);
+
+    // Perform the recursion.
+    for (NSView* subview in [view subviews])
+      CheckViewsDoNotObscure(subview);
+  }
+
+  // Checks that no views draw in front of |view|.
+  void CheckViewOnTop(NSView* view) {
+    belowExposedView_ = YES;
+    exposedView_ = view;
+    CheckViewsDoNotObscure([[[view window] contentView] superview]);

[Andre, 2014/10/10 04:37:13]

I still think it is not ideal to use instance variables that are only meaningful
when the recursion is in progress.
How about making a checker class and put the states there.
Something like,
  ViewsDoNotObscureChecker checker;  // needs a better class name
  checker.check(view);

Then,
  ViewsDoNotObscureChecker::Check(NSView* view) {
    belowExposedView_ = false;
    exposedView_ = view;
    CheckViewsDoNotObscure([[[view window] contentView] superview]);
  }

[erikchen, 2014/10/10 17:38:08]

I moved all of the logic into a new class.

+  }
+
+  // Nothing should draw on top of the window controls.
+  void VerifyWindowControlsZOrder() {
+    NSWindow* window = [controller() window];
+    CheckViewOnTop([window standardWindowButton:NSWindowCloseButton]);
+    CheckViewOnTop([window standardWindowButton:NSWindowMiniaturizeButton]);
+    CheckViewOnTop([window standardWindowButton:NSWindowZoomButton]);
+
+    // There is no fullscreen button on OSX 10.6 or OSX 10.10+.
+    NSView* view = [window standardWindowButton:NSWindowFullScreenButton];
+    if (view)
+      CheckViewOnTop(view);
   }
 
  private:
+  // The method CheckViewOnTop() recurses through the views in the view
+  // hierarchy and checks that none of the views obscure |exposedView_|.
+  NSView* exposedView_;
+  // While this flag is true, the views being recursed through are below
+  // |exposedView_| in Z-order. After the recursion passes |exposedView_|, this
+  // flag is set to false.
+  BOOL belowExposedView_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserWindowControllerTest);
 };
 
 // Tests that adding the first profile moves the Lion fullscreen button over
 // correctly.
 // DISABLED_ because it regularly times out: http://crbug.com/159002.
 IN_PROC_BROWSER_TEST_F(BrowserWindowControllerTest,
                        DISABLED_ProfileAvatarFullscreenButton) {
   if (base::mac::IsOSSnowLeopard())
     return;
@@ skipping 238 matching lines @@
 
   chrome::ExecuteCommand(browser(), IDC_SHOW_BOOKMARK_BAR);
   WaitForBookmarkBarAnimationToFinish();
   EXPECT_FALSE([controller() isBookmarkBarVisible]);
   EXPECT_EQ(std::min(GetExpectedTopInfoBarTipHeight(), max_tip_height),
             [[controller() infoBarContainerController] overlappingTipHeight]);
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserWindowControllerTest, TrafficLightZOrder) {
   // Verify z order immediately after creation.
-  VerifyTrafficLightZOrder();
+  VerifyWindowControlsZOrder();
 
-  // Toggle overlay, then verify z order.
+  // Verify z order in and out of overlay.
   [controller() showOverlay];
+  VerifyWindowControlsZOrder();
   [controller() removeOverlay];
-  VerifyTrafficLightZOrder();
+  VerifyWindowControlsZOrder();
 
-  // Toggle immersive fullscreen, then verify z order.
+  // Toggle immersive fullscreen, then verify z order. In immersive fullscreen,
+  // there are no window controls.
   [controller() enterImmersiveFullscreen];
   [controller() exitImmersiveFullscreen];
-  VerifyTrafficLightZOrder();
+  VerifyWindowControlsZOrder();
 }