Add ScopedMacRTL class for Cocoa browser RTL testing

chrome/browser/ui/cocoa/tabs/tab_strip_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/tabs/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 13 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #include "chrome/browser/ui/cocoa/drag_util.h"
 #import "chrome/browser/ui/cocoa/image_button_cell.h"
-#include "chrome/browser/ui/cocoa/l10n_util.h"
+#import "ui/base/cocoa/rtl_util.h"
 #import "chrome/browser/ui/cocoa/new_tab_button.h"
 #import "chrome/browser/ui/cocoa/tab_contents/favicon_util_mac.h"
 #import "chrome/browser/ui/cocoa/tab_contents/tab_contents_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/alert_indicator_button_cocoa.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_drag_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_model_observer_bridge.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_view.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #import "chrome/browser/ui/cocoa/themed_window.h"
@@ skipping 85 matching lines @@
       [[NSAnimationContext currentContext] setDuration:kMinimumTimeInterval];
     }
   }
 
 private:
   bool animate_;
   DISALLOW_COPY_AND_ASSIGN(ScopedNSAnimationContextGroup);
 };
 
 CGFloat FlipXInView(NSView* view, CGFloat width, CGFloat x) {
-  if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout())
+  if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout())
     return [view frame].size.width - x - width;
   return x;
 }
 
 NSRect FlipRectInView(NSView* view, NSRect rect) {
   rect.origin.x = FlipXInView(view, NSWidth(rect), NSMinX(rect));
   return rect;
 }
 
 }  // namespace
@@ skipping 673 matching lines @@
       // However, if the tab being closed is a pinned tab, break out of
       // rapid-closure mode since the mouse is almost guaranteed not to be over
       // the closebox of the adjacent tab (due to the difference in widths).
       // TODO(pinkerton): re-visit when handling tab overflow.
       // http://crbug.com/188
       if (tabStripModel_->IsTabPinned(index)) {
         availableResizeWidth_ = kUseFullAvailableWidth;
       } else {
         NSView* penultimateTab = [self viewAtIndex:numberOfOpenTabs - 2];
         availableResizeWidth_ =
-            cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+            cocoa_rtl_util::ShouldDoExperimentalRTLLayout()
                 ? FlipXInView(tabStripView_, 0, NSMinX([penultimateTab frame]))
                 : NSMaxX([penultimateTab frame]);
       }
     } else {
       // If the trailing tab is closed, change the available width so that
       // another tab's close button lands below the cursor (assuming the tabs
       // are currently below their maximum width and can grow).
       NSView* lastTab = [self viewAtIndex:numberOfOpenTabs - 1];
       availableResizeWidth_ =
-          cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+          cocoa_rtl_util::ShouldDoExperimentalRTLLayout()
               ? FlipXInView(tabStripView_, 0, NSMinX([lastTab frame]))
               : NSMaxX([lastTab frame]);
     }
     tabStripModel_->CloseWebContentsAt(
         index,
         TabStripModel::CLOSE_USER_GESTURE |
         TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
   } else {
     // Use the standard window close if this is the last tab
     // this prevents the tab from being removed from the model until after
@@ skipping 37 matching lines @@
   placeholderFrame_ = frame;
   [self layoutTabsWithAnimation:initialLayoutComplete_ regenerateSubviews:NO];
 }
 
 - (BOOL)isDragSessionActive {
   return placeholderTab_ != nil;
 }
 
 - (BOOL)isTabFullyVisible:(TabView*)tab {
   NSRect frame = [tab frame];
-  if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout()) {
+  if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout()) {
     return NSMinX(frame) >= [self trailingIndentForControls] &&
            NSMaxX(frame) <= [self tabAreaRightEdge];
   } else {
     return NSMinX(frame) >= [self leadingIndentForControls] &&
            NSMaxX(frame) <= [self tabAreaRightEdge];
   }
 }
 
 - (CGFloat)tabAreaRightEdge {
-  CGFloat rightEdge = cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+  CGFloat rightEdge = cocoa_rtl_util::ShouldDoExperimentalRTLLayout()
                           ? [self leadingIndentForControls]
                           : [self trailingIndentForControls];
   return NSMaxX([tabStripView_ frame]) - rightEdge;
 }
 
 - (void)showNewTabButton:(BOOL)show {
   forceNewTabButtonHidden_ = show ? NO : YES;
   if (forceNewTabButtonHidden_)
     [newTabButton_ setHidden:YES];
 }
@@ skipping 143 matching lines @@
       NSValue* identifier = [NSValue valueWithPointer:[tab view]];
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
       continue;
     }
 
     if (placeholderTab_ && !hasPlaceholderGap) {
       // If the back edge is behind the placeholder's back edge, but the
       // mid is in front of it of it, slide over to make space for it.
       bool shouldLeaveGap;
-      if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout()) {
+      if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout()) {
         const CGFloat tabMidpoint =
             NSMidX(FlipRectInView(tabStripView_, tabFrame));
         shouldLeaveGap = tabMidpoint < NSMaxX(placeholderFrame_);
       } else {
         shouldLeaveGap = NSMidX(tabFrame) > NSMinX(placeholderFrame_);
       }
       if (shouldLeaveGap) {
         hasPlaceholderGap = true;
         offset += NSWidth(placeholderFrame_);
         offset -= kTabOverlap;
@@ skipping 94 matching lines @@
   // be hidden, doing it again doesn't hurt. Otherwise position it
   // appropriately, showing it if necessary.
   if (forceNewTabButtonHidden_) {
     [newTabButton_ setHidden:YES];
   } else {
     NSRect newTabNewFrame = [newTabButton_ frame];
     // We've already ensured there's enough space for the new tab button
     // so we don't have to check it against the available space. We do need
     // to make sure we put it after any placeholder.
     CGFloat maxTabX = MAX(offset, NSMaxX(placeholderFrame_) - kTabOverlap);
-    if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout()) {
+    if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout()) {
       maxTabX = FlipXInView(tabStripView_, [newTabButton_ frame].size.width,
                             maxTabX) -
                 (2 * kNewTabButtonOffset);
     }
     newTabNewFrame.origin = NSMakePoint(maxTabX + kNewTabButtonOffset, 0);
     if ([tabContentsArray_ count])
       [newTabButton_ setHidden:NO];
 
     if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
       // Set the new tab button image correctly based on where the cursor is.
       NSWindow* window = [tabStripView_ window];
       NSPoint currentMouse = [window mouseLocationOutsideOfEventStream];
       currentMouse = [tabStripView_ convertPoint:currentMouse fromView:nil];
 
       BOOL shouldShowHover = [newTabButton_ pointIsOverButton:currentMouse];
       [self setNewTabButtonHoverState:shouldShowHover];
 
       // Move the new tab button into place. We want to animate the new tab
       // button if it's moving back (closing a tab), but not when it's
       // moving forward (inserting a new tab). If moving forward, we need
       // to use a very small duration to make sure we cancel any in-flight
       // animation to the left.
       if (visible && animate) {
         ScopedNSAnimationContextGroup localAnimationGroup(true);
         BOOL movingBack = NSMinX(newTabNewFrame) < NSMinX(newTabTargetFrame_);
-        if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout())
+        if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout())
           movingBack = !movingBack;
 
         if (!movingBack) {
           localAnimationGroup.SetCurrentContextShortestDuration();
         }
         [[newTabButton_ animator] setFrame:newTabNewFrame];
         newTabTargetFrame_ = newTabNewFrame;
       } else {
         [newTabButton_ setFrame:newTabNewFrame];
         newTabTargetFrame_ = newTabNewFrame;
@@ skipping 522 matching lines @@
 }
 
 - (int)indexOfPlaceholder {
   // Use |tabArray_| here instead of the tab strip count in order to get the
   // correct index when there are closing tabs to the left of the placeholder.
   const int count = [tabArray_ count];
 
   // No placeholder, return the end of the strip.
   if (placeholderTab_ == nil)
     return count;
-  BOOL isRTL = cocoa_l10n_util::ShouldDoExperimentalRTLLayout();
+  BOOL isRTL = cocoa_rtl_util::ShouldDoExperimentalRTLLayout();
   double placeholderX =
       isRTL ? NSMaxX(placeholderFrame_) : placeholderFrame_.origin.x;
   int index = 0;
   int location = 0;
   while (index < count) {
     // Ignore closing tabs for simplicity. The only drawback of this is that
     // if the placeholder is placed right before one or several contiguous
     // currently closing tabs, the associated TabController will start at the
     // end of the closing tabs.
     if ([closingControllers_ containsObject:[tabArray_ objectAtIndex:index]]) {
@@ skipping 271 matching lines @@
            disposition:(WindowOpenDisposition*)disposition
            activateTab:(BOOL)activateTab {
   // Proportion of the tab which is considered the "middle" (and causes things
   // to drop on that tab).
   const double kMiddleProportion = 0.5;
   const double kLRProportion = (1.0 - kMiddleProportion) / 2.0;
   const CGFloat kTabOverlap = [TabStripController tabOverlap];
 
   DCHECK(index && disposition);
   NSInteger i = 0;
-  BOOL isRTL = cocoa_l10n_util::ShouldDoExperimentalRTLLayout();
+  BOOL isRTL = cocoa_rtl_util::ShouldDoExperimentalRTLLayout();
   for (TabController* tab in tabArray_.get()) {
     NSView* view = [tab view];
     DCHECK([view isKindOfClass:[TabView class]]);
 
     // Recall that |-[NSView frame]| is in its superview's coordinates, so a
     // |TabView|'s frame is in the coordinates of the |TabStripView| (which
     // matches the coordinate system of |point|).
     NSRect frame = [view frame];
 
     // Modify the frame to make it "unoverlapped".
@@ skipping 201 matching lines @@
     return nil;
   NSInteger index = [self indexFromModelIndex:modelIndex];
   if (index < 0 ||
       index >= (NSInteger)[tabContentsArray_ count])
     return nil;
   return [tabContentsArray_ objectAtIndex:index];
 }
 
 - (void)addCustomWindowControls {
   BOOL shouldFlipWindowControls =
-      cocoa_l10n_util::ShouldFlipWindowControlsInRTL();
+      cocoa_rtl_util::ShouldFlipWindowControlsInRTL();
   if (!customWindowControls_) {
     // Make the container view.
     CGFloat height = NSHeight([tabStripView_ frame]);
     CGFloat width = [self leadingIndentForControls];
-    if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout() &&
+    if (cocoa_rtl_util::ShouldDoExperimentalRTLLayout() &&
         !shouldFlipWindowControls)
       // The trailing indent is correct in this case, since the controls should
       // stay on the left.
       width = [self trailingIndentForControls];
     CGFloat xOrigin =
         shouldFlipWindowControls ? NSWidth([tabStripView_ frame]) - width : 0;
     NSRect frame = NSMakeRect(xOrigin, 0, width, height);
     customWindowControls_.reset(
         [[CustomWindowControlsView alloc] initWithFrame:frame]);
     [customWindowControls_
@@ skipping 118 matching lines @@
   for (int i = 0; i < tabStripModel_->count(); i++) {
     [self updateIconsForContents:tabStripModel_->GetWebContentsAt(i) atIndex:i];
   }
 }
 
 - (void)setVisualEffectsDisabledForFullscreen:(BOOL)fullscreen {
   [tabStripView_ setVisualEffectsDisabledForFullscreen:fullscreen];
 }
 
 @end