Alternate NTP: Add search token to omnibox

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 "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_logging.h"
 #import "chrome/browser/ui/cocoa/location_bar/autocomplete_text_field.h"
@@ skipping 53 matching lines @@
 // 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. |action_padding| is the padding to use when the
 // first decoration is a button decoration, ie. the action box button.
 // (|DecorationHorizontalPad()| is used between decorations).
 void CalculatePositionsHelper(
     NSRect frame,
+    CGFloat text_width,
     const std::vector<LocationBarDecoration*>& all_decorations,
     NSRectEdge x_edge,
     CGFloat regular_padding,
     CGFloat action_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());
 
@@ skipping 11 matching lines @@
       }
 
       NSRect padding_rect, available;
 
       // Peel off the outside padding.
       NSDivideRect(frame, &padding_rect, &available, padding, x_edge);
 
       // Find out how large the decoration will be in the remaining
       // space.
       const CGFloat used_width =
-          all_decorations[i]->GetWidthForSpace(NSWidth(available));
+          all_decorations[i]->GetWidthForSpace(NSWidth(available), text_width);
 
       if (used_width != LocationBarDecoration::kOmittedWidth) {
         DCHECK_GT(used_width, 0.0);
         NSRect decoration_frame;
 
         // Peel off the desired width, leaving the remainder in
         // |frame|.
         NSDivideRect(available, &decoration_frame, &frame,
                      used_width, x_edge);
 
         decorations->push_back(all_decorations[i]);
         decoration_frames->push_back(decoration_frame);
         DCHECK_EQ(decorations->size(), decoration_frames->size());
 
         // Adjust padding for between decorations.
         padding = DecorationHorizontalPad();
       }
     }
   }
 
   DCHECK_EQ(decorations->size(), decoration_frames->size());
   *remaining_frame = frame;
 }
 
+// Hide separators at the beginning and end of the decorator list.
+void HideUnneededSeparators(
+    std::vector<LocationBarDecoration*>* decorations) {
+  if (!decorations->empty() && decorations->back()->IsSeparator())
+    decorations->pop_back();
+  if (!decorations->empty() && decorations->front()->IsSeparator())
+    decorations->erase(decorations->begin());
+}
+
 // Helper function for calculating placement of decorations w/in the cell.
 // |frame| is the cell's boundary rectangle, |remaining_frame| will get any
 // space left after decorations are laid out (for text).  |left_decorations| is
 // a set of decorations for the left-hand side of the cell, |right_decorations|
 // for the right-hand side.  |edge_width| is the width of one vertical edge of
 // the omnibox, this depends on whether the display is low DPI or high DPI.
 // |decorations| will contain the resulting visible decorations, and
 // |decoration_frames| will contain their frames in the same coordinates as
 // |frame|.  Decorations will be ordered left to right. As a convenience returns
 // the index of the first right-hand decoration.
 size_t CalculatePositionsInFrame(
     NSRect frame,
+    CGFloat text_width,
     const std::vector<LocationBarDecoration*>& left_decorations,
     const std::vector<LocationBarDecoration*>& right_decorations,
     CGFloat edge_width,
     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,
-                           kLeftDecorationXOffset, kLeftDecorationXOffset,
-                           decorations, decoration_frames, &frame);
-  DCHECK_EQ(decorations->size(), decoration_frames->size());
-
-  // Capture the number of visible left-hand decorations.
+  {
+    std::vector<LocationBarDecoration*> result_decorations;
+    std::vector<NSRect> result_frames;
+    NSRect result_frame = NSZeroRect;
+    CalculatePositionsHelper(frame, text_width, left_decorations, NSMinXEdge,
+                             kLeftDecorationXOffset, kLeftDecorationXOffset,
+                             &result_decorations, &result_frames,
+                             &result_frame);
+    HideUnneededSeparators(&result_decorations);
+    CalculatePositionsHelper(frame, text_width, result_decorations, NSMinXEdge,
+                             kLeftDecorationXOffset, kLeftDecorationXOffset,
+                             decorations, decoration_frames, &frame);
+  }
   const size_t left_count = decorations->size();
 
   // Layout |right_decorations| against the RHS.
-  CalculatePositionsHelper(frame, right_decorations, NSMaxXEdge,
-                           RightDecorationXOffset(), edge_width, decorations,
-                           decoration_frames, &frame);
-  DCHECK_EQ(decorations->size(), decoration_frames->size());
+  {
+    std::vector<LocationBarDecoration*> result_decorations;
+    std::vector<NSRect> result_frames;
+    NSRect result_frame = NSZeroRect;
+    CalculatePositionsHelper(frame, text_width, right_decorations, NSMaxXEdge,
+                             RightDecorationXOffset(), edge_width,
+                             &result_decorations, &result_frames,
+                             &result_frame);
+    HideUnneededSeparators(&result_decorations);
+    CalculatePositionsHelper(frame, text_width, result_decorations, NSMaxXEdge,
+                             RightDecorationXOffset(), edge_width,
+                             decorations, decoration_frames, &frame);
+  }
 
   // Reverse the right-hand decorations so that overall everything is
   // sorted left to right.
   std::reverse(decorations->begin() + left_count, decorations->end());
   std::reverse(decoration_frames->begin() + left_count,
                decoration_frames->end());
 
   *remaining_frame = frame;
   if (FeatureSwitch::script_badges()->IsEnabled()) {
     // Keep the padding distance between the right-most decoration and the edit
     // box, so that any decoration background isn't overwritten by the edit
     // box's background.
     NSRect dummy;
     NSDivideRect(frame, &dummy, remaining_frame,
                  DecorationHorizontalPad(), NSMaxXEdge);
   }
   return left_count;
 }
 
 }  // namespace
 
+@interface AutocompleteTextFieldCell ()
+- (CGFloat)textWidth;
+@end
+
 @implementation AutocompleteTextFieldCell
 
 - (CGFloat)baselineAdjust {
   return kBaselineAdjust;
 }
 
 - (CGFloat)cornerRadius {
   return kCornerRadius;
 }
 
@@ skipping 16 matching lines @@
 }
 
 - (void)addRightDecoration:(LocationBarDecoration*)decoration {
   rightDecorations_.push_back(decoration);
 }
 
 - (CGFloat)availableWidthInFrame:(const NSRect)frame {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(frame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(frame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   return NSWidth(textFrame);
 }
 
 - (NSRect)frameForDecoration:(const LocationBarDecoration*)aDecoration
                      inFrame:(NSRect)cellFrame {
   // Short-circuit if the decoration is known to be not visible.
   if (aDecoration && !aDecoration->IsVisible())
     return NSZeroRect;
 
   // Layout the decorations.
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(cellFrame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   // Find our decoration and return the corresponding frame.
   std::vector<LocationBarDecoration*>::const_iterator iter =
       std::find(decorations.begin(), decorations.end(), aDecoration);
   if (iter != decorations.end()) {
     const size_t index = iter - decorations.begin();
     return decorationFrames[index];
   }
 
-  // Decorations which are not visible should have been filtered out
-  // at the top, but return |NSZeroRect| rather than a 0-width rect
-  // for consistency.
-  NOTREACHED();
+  // The decoration is marked as visible but was either collapsed or hidden.
   return NSZeroRect;
 }
 
 // Overriden to account for the decorations.
 - (NSRect)textFrameForFrame:(NSRect)cellFrame {
   // Get the frame adjusted for decorations.
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame = [super textFrameForFrame:cellFrame];
-  CalculatePositionsInFrame(textFrame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(textFrame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   // NOTE: This function must closely match the logic in
   // |-drawInteriorWithFrame:inView:|.
 
   return textFrame;
 }
 
 // Returns the sub-frame where clicks can happen within the cell.
 - (NSRect)clickableFrameForFrame:(NSRect)cellFrame {
   return [super textFrameForFrame:cellFrame];
 }
 
 - (NSRect)textCursorFrameForFrame:(NSRect)cellFrame {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  size_t left_count =
-      CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
-                                [self edgeWidth], &decorations,
-                                &decorationFrames, &textFrame);
+  size_t left_count = CalculatePositionsInFrame(
+      cellFrame, [self textWidth], leftDecorations_, rightDecorations_,
+      [self edgeWidth], &decorations, &decorationFrames, &textFrame);
 
   // Determine the left-most extent for the i-beam cursor.
   CGFloat minX = NSMinX(textFrame);
   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);
@@ skipping 18 matching lines @@
 
   // I-beam cursor covers left-most to right-most.
   return NSMakeRect(minX, NSMinY(textFrame), maxX - minX, NSHeight(textFrame));
 }
 
 - (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect workingFrame;
 
-  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &workingFrame);
+  CalculatePositionsInFrame(cellFrame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &workingFrame);
 
   // Draw the decorations.
   for (size_t i = 0; i < decorations.size(); ++i) {
     if (decorations[i]) {
       NSRect background_frame = NSInsetRect(
           decorationFrames[i], -(DecorationHorizontalPad() + 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|.
   [super drawInteriorWithFrame:cellFrame inView:controlView];
 }
 
 - (LocationBarDecoration*)decorationForEvent:(NSEvent*)theEvent
                                       inRect:(NSRect)cellFrame
                                       ofView:(AutocompleteTextField*)controlView
 {
   const BOOL flipped = [controlView isFlipped];
   const NSPoint location =
       [controlView convertPoint:[theEvent locationInWindow] fromView:nil];
 
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(cellFrame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   for (size_t i = 0; i < decorations.size(); ++i) {
     if (NSMouseInRect(location, decorationFrames[i], flipped))
       return decorations[i];
   }
 
   return NULL;
 }
 
 - (NSMenu*)decorationMenuForEvent:(NSEvent*)theEvent
@@ skipping 131 matching lines @@
     [controlView setNeedsDisplay:YES];
   }
 }
 
 - (void)setUpTrackingAreasInRect:(NSRect)frame
                           ofView:(AutocompleteTextField*)view {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
   NSRect cellRect = [self clickableFrameForFrame:[view bounds]];
-  CalculatePositionsInFrame(cellRect, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(cellRect, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   // Remove previously-registered tracking areas, since we'll update them below.
   for (CrTrackingArea* area in [view trackingAreas]) {
     if ([[area userInfo] objectForKey:kButtonDecorationKey])
       [view removeTrackingArea:area];
   }
 
   // Setup new tracking areas for the buttons.
   for (size_t i = 0; i < decorations.size(); ++i) {
     ButtonDecoration* button = decorations[i]->AsButtonDecoration();
@@ skipping 194 matching lines @@
 
 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal {
   return NSDragOperationCopy;
 }
 
 - (void)updateToolTipsInRect:(NSRect)cellFrame
                       ofView:(AutocompleteTextField*)controlView {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(cellFrame, [self textWidth], leftDecorations_,
+                            rightDecorations_, [self edgeWidth], &decorations,
+                            &decorationFrames, &textFrame);
 
   for (size_t i = 0; i < decorations.size(); ++i) {
     NSString* tooltip = decorations[i]->GetToolTip();
     if ([tooltip length] > 0)
       [controlView addToolTip:tooltip forRect:decorationFrames[i]];
   }
 }
 
 - (BOOL)hideFocusState {
   return hideFocusState_;
 }
 
 - (void)setHideFocusState:(BOOL)hideFocusState
                    ofView:(AutocompleteTextField*)controlView {
   if (hideFocusState_ == hideFocusState)
     return;
   hideFocusState_ = hideFocusState;
   [controlView setNeedsDisplay:YES];
   NSTextView* fieldEditor =
       base::mac::ObjCCastStrict<NSTextView>([controlView currentEditor]);
   [fieldEditor updateInsertionPointStateAndRestartTimer:YES];
 }
 
 - (BOOL)showsFirstResponder {
   return [super showsFirstResponder] && !hideFocusState_;
 }
 
+- (CGFloat)textWidth {
+  return [[self attributedStringValue] size].width;
+}
+
 @end