cocoa browser: remove non-MD location bar support

chrome/browser/ui/cocoa/location_bar/autocomplete_text_field_cell.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/location_bar/autocomplete_text_field_cell.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
@@ skipping 14 matching lines @@
 using extensions::FeatureSwitch;
 
 namespace {
 
 // Matches the clipping radius of |GradientButtonCell|.
 const CGFloat kCornerRadius = 3.0;
 
 // How far to inset the left- and right-hand decorations from the field's
 // bounds.
 const CGFloat kRightDecorationXOffset = 5.0;
-CGFloat LeftDecorationXOffset() {
-  const CGFloat kLeftDecorationXOffset = 5.0;
-  const CGFloat kLeftMaterialDecorationXOffset = 6.0;
-  return ui::MaterialDesignController::IsModeMaterial()
-             ? kLeftMaterialDecorationXOffset
-             : kLeftDecorationXOffset;
-}
+const CGFloat kLeftDecorationXOffset = 6.0;
 
 // The amount of padding on either side reserved for drawing
 // decorations.  [Views has |kItemPadding| == 3.]
-CGFloat DecorationsHorizontalPad() {
-  const CGFloat kDecorationHorizontalPad = 3.0;
-  const CGFloat kMaterialDecorationHorizontalPad = 4.0;
-  return ui::MaterialDesignController::IsModeMaterial()
-      ? kMaterialDecorationHorizontalPad
-      : kDecorationHorizontalPad;
-}
-
-const ui::NinePartImageIds kPopupBorderImageIds =
-    IMAGE_GRID(IDR_OMNIBOX_POPUP_BORDER_AND_SHADOW);
-
-const ui::NinePartImageIds kNormalBorderImageIds = IMAGE_GRID(IDR_TEXTFIELD);
+const CGFloat kDecorationHorizontalPad = 4.0;
 
 // How long to wait for mouse-up on the location icon before assuming
 // that the user wants to drag.
 const NSTimeInterval kLocationIconDragTimeout = 0.25;
 
 // Calculate the positions for a set of decorations.  |frame| is the
 // overall frame to do layout in, |remaining_frame| will get the
 // left-over space.  |all_decorations| is the set of decorations to
 // lay out, |decorations| will be set to the decorations which are
 // visible and which fit, in the same order as |all_decorations|,
 // while |decoration_frames| will be the corresponding frames.
 // |x_edge| describes the edge to layout the decorations against
 // (|NSMinXEdge| or |NSMaxXEdge|).  |regular_padding| is the padding
 // from the edge of |cell_frame| to use when the first visible decoration
 // is a regular decoration.
 void CalculatePositionsHelper(
     NSRect frame,
     const std::vector<LocationBarDecoration*>& all_decorations,
     NSRectEdge x_edge,
     CGFloat regular_padding,
     std::vector<LocationBarDecoration*>* decorations,
     std::vector<NSRect>* decoration_frames,
     NSRect* remaining_frame) {
   DCHECK(x_edge == NSMinXEdge || x_edge == NSMaxXEdge);
   DCHECK_EQ(decorations->size(), decoration_frames->size());
 
   // The initial padding depends on whether the first visible decoration is
   // a button or not.
   bool is_first_visible_decoration = true;
-  const CGFloat kDecorationHorizontalPad = DecorationsHorizontalPad();
 
   for (size_t i = 0; i < all_decorations.size(); ++i) {
     if (all_decorations[i]->IsVisible()) {
       CGFloat padding = kDecorationHorizontalPad;
       if (is_first_visible_decoration) {
         padding = regular_padding;
         is_first_visible_decoration = false;
       }
 
       NSRect padding_rect, available;
@@ skipping 43 matching lines @@
     const std::vector<LocationBarDecoration*>& left_decorations,
     const std::vector<LocationBarDecoration*>& right_decorations,
     std::vector<LocationBarDecoration*>* decorations,
     std::vector<NSRect>* decoration_frames,
     NSRect* remaining_frame) {
   decorations->clear();
   decoration_frames->clear();
 
   // Layout |left_decorations| against the LHS.
   CalculatePositionsHelper(frame, left_decorations, NSMinXEdge,
-                           LeftDecorationXOffset(), decorations,
+                           kLeftDecorationXOffset, decorations,
                            decoration_frames, &frame);
   DCHECK_EQ(decorations->size(), decoration_frames->size());
 
   // Capture the number of visible left-hand decorations.
   const size_t left_count = decorations->size();
 
   // Layout |right_decorations| against the RHS.
   CalculatePositionsHelper(frame, right_decorations, NSMaxXEdge,
                            kRightDecorationXOffset, decorations,
                            decoration_frames, &frame);
@@ skipping 95 matching lines @@
   NSRect textFrame = [super textFrameForFrame:cellFrame];
   CalculatePositionsInFrame(textFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &textFrame);
 
   // The text needs to be slightly higher than its default position to match the
   // Material Design spec. It turns out this adjustment is equal to the single
   // pixel line width (so 1 on non-Retina, 0.5 on Retina). Make this adjustment
   // after computing decoration positions because the decorations are already
   // correctly positioned. The spec also calls for positioning the text 1pt to
   // the right of its default position.
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    textFrame.origin.x += 1;
-    textFrame.size.width -= 1;
-    textFrame.origin.y -= singlePixelLineWidth_;
-  }
+  textFrame.origin.x += 1;
+  textFrame.size.width -= 1;
+  textFrame.origin.y -= singlePixelLineWidth_;
 
   // NOTE: This function must closely match the logic in
   // |-drawInteriorWithFrame:inView:|.
 
   return textFrame;
 }
 
 - (NSRect)textCursorFrameForFrame:(NSRect)cellFrame {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
   size_t left_count =
       CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
                                 &decorations, &decorationFrames, &textFrame);
 
   // Determine the left-most extent for the i-beam cursor.
   CGFloat minX = NSMinX(textFrame);
-  const CGFloat kDecorationHorizontalPad = DecorationsHorizontalPad();
   for (size_t index = left_count; index--; ) {
     if (decorations[index]->AcceptsMousePress())
       break;
 
     // If at leftmost decoration, expand to edge of cell.
     if (!index) {
       minX = NSMinX(cellFrame);
     } else {
       minX = NSMinX(decorationFrames[index]) - kDecorationHorizontalPad;
     }
@@ skipping 11 matching lines @@
     } else {
       maxX = NSMaxX(decorationFrames[index]) + kDecorationHorizontalPad;
     }
   }
 
   // I-beam cursor covers left-most to right-most.
   return NSMakeRect(minX, NSMinY(textFrame), maxX - minX, NSHeight(textFrame));
 }
 
 - (void)drawWithFrame:(NSRect)frame inView:(NSView*)controlView {
-  BOOL isModeMaterial = ui::MaterialDesignController::IsModeMaterial();
   BOOL inDarkMode = [[controlView window] inIncognitoModeWithSystemTheme];
   BOOL showingFirstResponder = [self showsFirstResponder];
   // Adjust the inset by 1/2 the line width to get a crisp line (screen pixels
   // lay between cooridnate space lines).
   CGFloat insetSize = 1 - singlePixelLineWidth_ / 2.;
-  if (isModeMaterial && showingFirstResponder && !inDarkMode) {
+  if (showingFirstResponder && !inDarkMode) {
     insetSize++;
-  } else if (!isModeMaterial) {
-    insetSize = singlePixelLineWidth_ == 0.5 ? 1.5 : 2.0;
   }
 
   // Compute the border's bezier path.
   NSRect pathRect = NSInsetRect(frame, insetSize, insetSize);
   NSBezierPath* path =
       [NSBezierPath bezierPathWithRoundedRect:pathRect
                                       xRadius:kCornerRadius
                                       yRadius:kCornerRadius];
-  if (isModeMaterial) {
-    [path setLineWidth:showingFirstResponder ? singlePixelLineWidth_ * 2
-                                             : singlePixelLineWidth_];
-  }
+  [path setLineWidth:showingFirstResponder ? singlePixelLineWidth_ * 2
+                                           : singlePixelLineWidth_];
 
   // Fill the background.
   [[self backgroundColor] set];
   if (isPopupMode_) {
     NSRectFillUsingOperation(NSInsetRect(frame, 1, 1), NSCompositeSourceOver);
   } else {
     [path fill];
   }
 
   // Draw the border.
-  if (isModeMaterial) {
-    if (!inDarkMode) {
-      const CGFloat kNormalStrokeGray = 168 / 255.;
-      [[NSColor colorWithCalibratedWhite:kNormalStrokeGray alpha:1] set];
-    } else {
-      const CGFloat k30PercentAlpha = 0.3;
-      [[NSColor colorWithCalibratedWhite:0 alpha:k30PercentAlpha] set];
-    }
-    [path stroke];
+  if (!inDarkMode) {
+    const CGFloat kNormalStrokeGray = 168 / 255.;
+    [[NSColor colorWithCalibratedWhite:kNormalStrokeGray alpha:1] set];
   } else {
-    ui::DrawNinePartImage(frame,
-                          isPopupMode_ ? kPopupBorderImageIds
-                                       : kNormalBorderImageIds,
-                          NSCompositeSourceOver,
-                          1.0,
-                          true);
+    const CGFloat k30PercentAlpha = 0.3;
+    [[NSColor colorWithCalibratedWhite:0 alpha:k30PercentAlpha] set];
   }
+  [path stroke];
 
   // Draw the interior contents. We do this after drawing the border as some
   // of the interior controls draw over it.
   [self drawInteriorWithFrame:frame inView:controlView];
 
   // Draw the focus ring.
   if (showingFirstResponder) {
-    if (!isModeMaterial) {
-      NSRect focusRingRect =
-          NSInsetRect(frame, singlePixelLineWidth_, singlePixelLineWidth_);
-      path = [NSBezierPath bezierPathWithRoundedRect:focusRingRect
-                                             xRadius:kCornerRadius
-                                             yRadius:kCornerRadius];
-      [path setLineWidth:singlePixelLineWidth_ * 2.0];
-    }
-
     CGFloat alphaComponent = 0.5 / singlePixelLineWidth_;
-    if (isModeMaterial && inDarkMode) {
+    if (inDarkMode) {
       // Special focus color for Material Incognito.
       [[NSColor colorWithSRGBRed:123 / 255.
                            green:170 / 255.
                             blue:247 / 255.
                            alpha:1] set];
     } else {
       [[[NSColor keyboardFocusIndicatorColor]
           colorWithAlphaComponent:alphaComponent] set];
     }
     [path stroke];
   }
 }
 
 - (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect workingFrame;
 
   CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
                             &decorations, &decorationFrames, &workingFrame);
 
   // Draw the decorations.
-  const CGFloat kDecorationHorizontalPad = DecorationsHorizontalPad();
   for (size_t i = 0; i < decorations.size(); ++i) {
     if (decorations[i]) {
       NSRect background_frame = NSInsetRect(
           decorationFrames[i], -(kDecorationHorizontalPad + 1) / 2, 2);
       decorations[i]->DrawWithBackgroundInFrame(
           background_frame, decorationFrames[i], controlView);
     }
   }
 
   // NOTE: This function must closely match the logic in
   // |-textFrameForFrame:|.
 
   // Superclass draws text portion WRT original |cellFrame|.
   ui::ScopedCGContextSmoothFonts fontSmoothing;
   [super drawInteriorWithFrame:cellFrame inView:controlView];
 }
 
 - (BOOL)canDropAtLocationInWindow:(NSPoint)location
                            ofView:(AutocompleteTextField*)controlView {
   NSRect cellFrame = [controlView bounds];
   const NSPoint locationInView =
       [controlView convertPoint:location fromView:nil];
 
   // If we have decorations, the drop can't occur at their horizontal padding.
-  if (!leftDecorations_.empty() && locationInView.x < LeftDecorationXOffset())
+  if (!leftDecorations_.empty() && locationInView.x < kLeftDecorationXOffset)
     return false;
 
   if (!rightDecorations_.empty() &&
       locationInView.x > NSWidth(cellFrame) - kRightDecorationXOffset) {
     return false;
   }
 
   LocationBarDecoration* decoration =
       [self decorationForLocationInWindow:location
                                    inRect:cellFrame
@@ skipping 331 matching lines @@
 
 - (void)handleFocusEvent:(NSEvent*)event
                   ofView:(AutocompleteTextField*)controlView {
   if ([controlView observer]) {
     const bool controlDown = ([event modifierFlags] & NSControlKeyMask) != 0;
     [controlView observer]->OnSetFocus(controlDown);
   }
 }
 
 @end