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"
 #import "chrome/browser/ui/cocoa/location_bar/button_decoration.h"
 #import "chrome/browser/ui/cocoa/location_bar/location_bar_decoration.h"
 #import "chrome/browser/ui/cocoa/nsview_additions.h"
 #import "chrome/browser/ui/cocoa/tracking_area.h"
 #import "chrome/common/extensions/feature_switch.h"
 #import "third_party/mozilla/NSPasteboard+Utils.h"
 
 using extensions::FeatureSwitch;
 
 namespace {
 
 const CGFloat kBaselineAdjust = 3.0;
 
 // Matches the clipping radius of |GradientButtonCell|.
 const CGFloat kCornerRadius = 3.0;
 
 // How far to inset the left-hand decorations from the field's bounds.
 const CGFloat kLeftDecorationXOffset = 5.0;
 
+// Padding between the control's text and the collapsible decoration.
+const CGFloat kAutoCollapsePadding = 20.0;
+
 NSString* const kButtonDecorationKey = @"ButtonDecoration";
 
 // How far to inset the right-hand decorations from the field's bounds.
 // TODO(shess): Why is this different from |kLeftDecorationXOffset|?
 // |kDecorationOuterXOffset|?
 CGFloat RightDecorationXOffset() {
   const CGFloat kRightDecorationXOffset = 5.0;
   const CGFloat kScriptBadgeRightDecorationXOffset = 9.0;
 
   if (FeatureSwitch::script_badges()->IsEnabled()) {
@@ skipping 24 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 10 matching lines @@
         is_first_visible_decoration = false;
       }
 
       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 =
+      CGFloat used_width =
           all_decorations[i]->GetWidthForSpace(NSWidth(available));
 
+      // Collapse if necessary.

[Scott Hess - ex-Googler, 2013/01/28 21:37:27]

Way Back When, I thought that this kind of auto-adjusting layout decision was
being handled in LocationBarViewMac::Layout(), because that's where it was being
handled for other platforms.  But I don't see obvious evidence of this, and
other platforms have changed a bunch in this area.  The main rationale for this
was so that in the future people wouldn't distribute things randomly across the
code and make it hard to understand.  Since you're already looking at the code
from other platforms, please give it a pass to see if this code will make sense
when someone from that platform sees it, in case it needs adjustment.

[sail, 2013/01/29 22:31:08]

I think moving this might be a good idea. In views all this logic is in a
special class (LocationBarLayout). We could do the same.
I've filed http://crbug.com/172949 to track this work.

+      CGFloat new_width = NSWidth(available) - used_width -
+                          kAutoCollapsePadding;
+      if (all_decorations[i]->ShouldAutoCollapse() && new_width < text_width)
+        used_width = LocationBarDecoration::kOmittedWidth;

[Scott Hess - ex-Googler, 2013/01/28 21:37:27]

I wonder if this wouldn't make more sense to fold into GetWidthForSpace(),
rather than having two places for the knowledge to live?  I think that if we
really want this (*), it would be reasonable to pass down both "total available
space" as NSWidth(available) and "desired decoration space" as
NSWidth(available) - text_width.  Then the decoration can make the decision
about collapsing and how much padding to consider.

(*) I think that there used to be more collapsing going on in the location-bar
code, but we moved away from it for some reason.

[sail, 2013/01/29 22:31:08]

Done.
Moved the collapse logic to SearchTokenDecoration::GetWidthForSpace(). Added
text_width as a parameter to GetWidthForSpace().

+
       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->front()->AsSeparatorDecoration())
+    decorations->erase(decorations->begin());
+  if (!decorations->empty() && decorations->back()->AsSeparatorDecoration())
+    decorations->pop_back();
+}
+
 // 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);

[Scott Hess - ex-Googler, 2013/01/28 21:37:27]

The helper already knows about applying auto-collapse, I don't think it would be
materially worse to have it also know how to check for separators against the
endpoints, at least versus having this code duplication here.  It would need two
tests, one inside the loop and one outside, but HideUnneededSeparators() also
needs two tests.  I don't have the heart to dig into the other-platform code to
see if as-is matches that better.

[sail, 2013/01/29 22:31:08]

The views code also does two passes.
I tried moving the check inside the loop in CalculatePositionsHelper() but the
logic to update the frames became too complicated. 

I find doing two passes a lot easier to understand.

[Scott Hess - ex-Googler, 2013/01/29 23:28:36]

OK.  My main concern is whether there will be subtle issues due to the passes
not returning the same values.

+    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
@@ skipping 37 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);
+  NSAttributedString* text = [self attributedStringValue];

[Scott Hess - ex-Googler, 2013/01/28 21:37:27]

Suggest either a helper for "[[self attributedStringValue] size].width", or
re-casting CalculatePositionsInFrame() as a method.  I think I'd prefer the
former, a big reason why it's a function in the anon namespace is because I want
to prevent people from reaching out to random area of the profile to influence
layout dynamically.

[sail, 2013/01/29 22:31:08]

Done.
Added a helper method -[AutocompleteTextFieldCell textWidth]

+  CalculatePositionsInFrame(frame, [text size].width, 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);
+  NSAttributedString* text = [self attributedStringValue];
+  CalculatePositionsInFrame(cellFrame, [text size].width, 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 {
+  NSAttributedString* text = [self attributedStringValue];
+
   // 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, [text size].width, 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 {
+  NSAttributedString* text = [self attributedStringValue];
   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, [text size].width, 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);
+  NSAttributedString* text = [self attributedStringValue];
+  CalculatePositionsInFrame(cellFrame, [text size].width, 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];
+  NSAttributedString* text = [self attributedStringValue];
 
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
-  CalculatePositionsInFrame(cellFrame, leftDecorations_, rightDecorations_,
+  CalculatePositionsInFrame(cellFrame, [text size].width, 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;
 }
@@ skipping 132 matching lines @@
     decoration->SetButtonState(ButtonDecoration::kButtonStateNormal);
     [controlView setNeedsDisplay:YES];
   }
 }
 
 - (void)setUpTrackingAreasInRect:(NSRect)frame
                           ofView:(AutocompleteTextField*)view {
   std::vector<LocationBarDecoration*> decorations;
   std::vector<NSRect> decorationFrames;
   NSRect textFrame;
+  NSAttributedString* text = [self attributedStringValue];
   NSRect cellRect = [self clickableFrameForFrame:[view bounds]];
-  CalculatePositionsInFrame(cellRect, leftDecorations_, rightDecorations_,
-                            [self edgeWidth], &decorations, &decorationFrames,
-                            &textFrame);
+  CalculatePositionsInFrame(cellRect, [text size].width, 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);
+  NSAttributedString* text = [self attributedStringValue];
+  CalculatePositionsInFrame(cellFrame, [text size].width, 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_;
 }
 
 @end