Mac: Style the omnibox URL.

chrome/browser/autocomplete/autocomplete_edit_view_mac.mm

 // Copyright (c) 2009 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.
 
 #include "chrome/browser/autocomplete/autocomplete_edit_view_mac.h"
 
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_edit.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_model.h"
 #include "chrome/browser/autocomplete/autocomplete_popup_view_mac.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 
 namespace {
 
+// TODO(shess): This is ugly, find a better way.  Using it right now
+// so that I can crib from gtk and still be able to see that I'm using
+// the same values easily.
+const NSColor* ColorWithRGBBytes(int rr, int gg, int bb) {
+  DCHECK_LE(rr, 255);
+  DCHECK_LE(bb, 255);
+  DCHECK_LE(gg, 255);
+  return [NSColor colorWithCalibratedRed:static_cast<float>(rr)/255.0
+                                   green:static_cast<float>(gg)/255.0
+                                    blue:static_cast<float>(bb)/255.0
+                                   alpha:1.0];
+}
+const NSColor* SecureBackgroundColor() {
+  return ColorWithRGBBytes(255, 245, 195);  // Yellow
+}
+const NSColor* NormalBackgroundColor() {
+  return [NSColor controlBackgroundColor];
+}
+const NSColor* InsecureBackgroundColor() {
+  return [NSColor controlBackgroundColor];
+}
+
+const NSColor* HostTextColor() {
+  return [NSColor blackColor];
+}
+const NSColor* BaseTextColor() {
+  return [NSColor darkGrayColor];
+}
+const NSColor* SecureSchemeColor() {
+  return ColorWithRGBBytes(0x00, 0x96, 0x14);
+}
+const NSColor* InsecureSchemeColor() {
+  return ColorWithRGBBytes(0xc8, 0x00, 0x00);
+}
+
 // Store's the model and view state across tab switches.
 struct AutocompleteEditViewMacState {
   AutocompleteEditViewMacState(const AutocompleteEditModel::State model_state,
                                const bool has_focus, const NSRange& selection)
       : model_state(model_state),
         has_focus(has_focus),
         selection(selection) {
   }
 
   const AutocompleteEditModel::State model_state;
@@ skipping 12 matching lines @@
 
 // Accessors for storing and getting the state from the tab.
 void StoreStateToTab(TabContents* tab,
                      const AutocompleteEditViewMacState& state) {
   GetStateAccessor()->SetProperty(tab->property_bag(), state);
 }
 const AutocompleteEditViewMacState* GetStateFromTab(const TabContents* tab) {
   return GetStateAccessor()->GetProperty(tab->property_bag());
 }
 
+// Helper to make converting url_parse ranges to NSRange easier to
+// read.
+NSRange ComponentToNSRange(const url_parse::Component& component) {
+  return NSMakeRange(static_cast<NSInteger>(component.begin),
+                     static_cast<NSInteger>(component.len));
+}
+
 }  // namespace
 
 // Thin Obj-C bridge class that is the delegate of the omnibox field.
 // It intercepts various control delegate methods and vectors them to
 // the edit view.
 
 @interface AutocompleteFieldDelegate : NSObject {
  @private
   AutocompleteEditViewMac* edit_view_;  // weak, owns us.
 }
@@ skipping 13 matching lines @@
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       field_(field),
       edit_helper_([[AutocompleteFieldDelegate alloc] initWithEditView:this]) {
   DCHECK(controller);
   DCHECK(toolbar_model);
   DCHECK(profile);
   DCHECK(command_updater);
   DCHECK(field);
   [field_ setDelegate:edit_helper_];
+
+  // Needed so that editing doesn't lose the styling.
+  [field_ setAllowsEditingTextAttributes:YES];
 }
 
 AutocompleteEditViewMac::~AutocompleteEditViewMac() {
   // TODO(shess): Having to be aware of destructor ordering in this
   // way seems brittle.  There must be a better way.
 
   // Destroy popup view before this object in case it tries to call us
   // back in the destructor.  Likewise for destroying the model before
   // this object.
   popup_view_.reset();
@@ skipping 40 matching lines @@
       // Should restore the user's text via SetUserText().
       model_->RestoreState(state->model_state);
 
       // Restore user's selection.
       // TODO(shess): The model_ does not restore the focus state.  If
       // field_ was in focus when we switched away, I presume it
       // should be in focus when we switch back.  Figure out if model_
       // not restoring focus is an oversight, or intentional for some
       // subtle reason.
       if (state->has_focus) {
-        FocusLocation();
-        DCHECK([field_ currentEditor]);
-        [[field_ currentEditor] setSelectedRange:state->selection];
+        SetSelectedRange(state->selection);
       }
     }
   } else if (user_visible) {
     // Restore everything to the baseline look.
     RevertAll();
     // TODO(shess): Figure out how this case is used, to make sure
     // we're getting the selection and popup right.
 
   } else {
     // TODO(shess): Figure out how this case is used, to make sure
     // we're getting the selection and popup right.
-    // UpdateAndStyleText() approximates the inner part of Revertall()
-    // which under GTK is called EmphasizeURLComponents(), and is
-    // expected to change when I start feeding in the styling code.
-    UpdateAndStyleText(text, 0);
+    UpdateAndStyleText(text);
   }
 }
 
 void AutocompleteEditViewMac::OpenURL(const GURL& url,
                                       WindowOpenDisposition disposition,
                                       PageTransition::Type transition,
                                       const GURL& alternate_nav_url,
                                       size_t selected_line,
                                       const std::wstring& keyword) {
   // TODO(shess): Why is the caller passing an invalid url in the
@@ skipping 12 matching lines @@
 }
 
 std::wstring AutocompleteEditViewMac::GetText() const {
   return base::SysNSStringToWide([field_ stringValue]);
 }
 
 void AutocompleteEditViewMac::SetUserText(const std::wstring& text,
                                           const std::wstring& display_text,
                                           bool update_popup) {
   model_->SetUserText(text);
-  UpdateAndStyleText(display_text, display_text.size());
+  // TODO(shess): TODO below from gtk.
+  // TODO(deanm): something about selection / focus change here.
+  UpdateAndStyleText(display_text);
   if (update_popup) {
     UpdatePopup();
   }
 }
 
 NSRange AutocompleteEditViewMac::GetSelectedRange() const {
   DCHECK([field_ currentEditor]);
   return [[field_ currentEditor] selectedRange];
 }
 
+void AutocompleteEditViewMac::SetSelectedRange(const NSRange range) {
+  // TODO(shess): Check if we should steal focus or not.  We can't set
+  // the selection without focus, though.
+  FocusLocation();
+
+  // TODO(shess): What if it didn't get first responder, and there is
+  // no field editor?  This will do nothing.  Well, at least it won't
+  // crash.  Think of something more productive to do, or prove that
+  // it cannot occur and DCHECK appropriately.
+  [[field_ currentEditor] setSelectedRange:range];
+}
+
 void AutocompleteEditViewMac::SetWindowTextAndCaretPos(const std::wstring& text,
                                                        size_t caret_pos) {
-  UpdateAndStyleText(text, text.size());
+  DCHECK_LE(caret_pos, text.size());
+  UpdateAndStyleText(text);
+  SetSelectedRange(NSMakeRange(caret_pos, caret_pos));
 }
 
 void AutocompleteEditViewMac::SelectAll(bool reversed) {
-  // TODO(shess): Figure out what reversed implies.  The gtk version
+  // TODO(shess): Figure out what |reversed| implies.  The gtk version
   // has it imply inverting the selection front to back, but I don't
   // even know if that makes sense for Mac.
-  UpdateAndStyleText(GetText(), 0);
+
+  // TODO(shess): Verify that we should be stealing focus at this
+  // point.
+  SetSelectedRange(NSMakeRange(0, GetText().size()));
 }
 
 void AutocompleteEditViewMac::RevertAll() {
   ClosePopup();
   model_->Revert();
 
-  std::wstring tt = GetText();
-  UpdateAndStyleText(tt, 0);
+  UpdateAndStyleText(GetText());
   controller_->OnChanged();
 }
 
 void AutocompleteEditViewMac::UpdatePopup() {
   model_->SetInputInProgress(true);
   if (!model_->has_focus())
     return;
 
   // TODO(shess):
   // Shouldn't inline autocomplete when the caret/selection isn't at
   // the end of the text.
   //
   // One option would seem to be to check for a non-nil field
   // editor, and check it's selected range against its length.
   model_->StartAutocomplete(false);
 }
 
 void AutocompleteEditViewMac::ClosePopup() {
   popup_view_->GetModel()->StopAutocomplete();
 }
 
 void AutocompleteEditViewMac::UpdateAndStyleText(
-    const std::wstring& display_text, size_t user_text_length) {
-  NSDictionary* attributes = [NSDictionary dictionaryWithObjectsAndKeys:
-                                  [field_ font], NSFontAttributeName,
-                                  nil];
+    const std::wstring& display_text) {
   NSString* ss = base::SysWideToNSString(display_text);
   NSMutableAttributedString* as =
-      [[[NSMutableAttributedString alloc] initWithString:ss
-                                              attributes:attributes]
-        autorelease];
+      [[[NSMutableAttributedString alloc] initWithString:ss] autorelease];
+  [as addAttribute:NSFontAttributeName value:[field_ font]
+             range:NSMakeRange(0, [as length])];
 
   url_parse::Parsed parts;
   AutocompleteInput::Parse(display_text, model_->GetDesiredTLD(),
                            &parts, NULL);
-  bool emphasize = model_->CurrentTextIsURL() && (parts.host.len > 0);
+  const bool emphasize = model_->CurrentTextIsURL() && (parts.host.len > 0);
   if (emphasize) {
-    // TODO(shess): Pull color out as a constant.
-    [as addAttribute:NSForegroundColorAttributeName
-               value:[NSColor greenColor]
-               range:NSMakeRange((NSInteger)parts.host.begin,
-                                 (NSInteger)parts.host.len)];
+    [as addAttribute:NSForegroundColorAttributeName value:BaseTextColor()
+               range:NSMakeRange(0, [as length])];
+
+    [as addAttribute:NSForegroundColorAttributeName value:HostTextColor()
+               range:ComponentToNSRange(parts.host)];
   }
 
   // TODO(shess): GTK has this as a member var, figure out why.
-  ToolbarModel::SecurityLevel scheme_security_level =
+  // [Could it be to not change if no change?  If so, I'm guessing
+  // AppKit may already handle that.]
+  const ToolbarModel::SecurityLevel scheme_security_level =
       toolbar_model_->GetSchemeSecurityLevel();
 
+  if (scheme_security_level == ToolbarModel::SECURE) {
+    [field_ setBackgroundColor:SecureBackgroundColor()];
+  } else if (scheme_security_level == ToolbarModel::NORMAL) {
+    [field_ setBackgroundColor:NormalBackgroundColor()];
+  } else if (scheme_security_level == ToolbarModel::INSECURE) {
+    [field_ setBackgroundColor:InsecureBackgroundColor()];
+  } else {
+    NOTREACHED() << "Unexpected scheme_security_level: "
+                 << scheme_security_level;
+  }
+
   // Emphasize the scheme for security UI display purposes (if necessary).
   if (!model_->user_input_in_progress() && parts.scheme.is_nonempty() &&
       (scheme_security_level != ToolbarModel::NORMAL)) {
-    // TODO(shess): Pull colors out as constants.
     NSColor* color;
     if (scheme_security_level == ToolbarModel::SECURE) {
-      color = [NSColor blueColor];
+      color = SecureSchemeColor();
     } else {
-      color = [NSColor blackColor];
+      color = InsecureSchemeColor();
     }
     [as addAttribute:NSForegroundColorAttributeName value:color
-               range:NSMakeRange((NSInteger)parts.scheme.begin,
-                                 (NSInteger)parts.scheme.len)];
+               range:ComponentToNSRange(parts.scheme)];
   }
 
-  // TODO(shess): Check that this updates the model's sense of focus
-  // correctly.
   [field_ setObjectValue:as];
-  if (![field_ currentEditor]) {
-    [field_ becomeFirstResponder];
-    DCHECK_EQ([field_ currentEditor], [[field_ window] firstResponder]);
-  }
-
-  NSRange selected_range = NSMakeRange(user_text_length, [as length]);
-  // TODO(shess): What if it didn't get first responder, and there is
-  // no field editor?  This will do nothing.  Well, at least it won't
-  // crash.  Think of something more productive to do, or prove that
-  // it cannot occur and DCHECK appropriately.
-  [[field_ currentEditor] setSelectedRange:selected_range];
 }
 
 void AutocompleteEditViewMac::OnTemporaryTextMaybeChanged(
     const std::wstring& display_text, bool save_original_selection) {
   // TODO(shess): I believe this is for when the user arrows around
   // the popup, will be restored if they hit escape.  Figure out if
   // that is for certain it.
   if (save_original_selection) {
+    saved_temporary_selection_ = GetSelectedRange();
     saved_temporary_text_ = GetText();
   }
 
-  UpdateAndStyleText(display_text, display_text.size());
+  SetWindowTextAndCaretPos(display_text, display_text.size());
 }
 
 bool AutocompleteEditViewMac::OnInlineAutocompleteTextMaybeChanged(
     const std::wstring& display_text, size_t user_text_length) {
   // TODO(shess): Make sure that this actually works.  The round trip
   // to native form and back may mean that it's the same but not the
   // same.
   if (display_text == GetText()) {
     return false;
   }
 
-  UpdateAndStyleText(display_text, user_text_length);
+  UpdateAndStyleText(display_text);
+  DCHECK_LE(user_text_length, display_text.size());
+  SetSelectedRange(NSMakeRange(user_text_length, display_text.size()));
   return true;
 }
 
 void AutocompleteEditViewMac::OnRevertTemporaryText() {
-  UpdateAndStyleText(saved_temporary_text_, saved_temporary_text_.size());
+  UpdateAndStyleText(saved_temporary_text_);
   saved_temporary_text_.clear();
+  SetSelectedRange(saved_temporary_selection_);
 }
 
 void AutocompleteEditViewMac::OnBeforePossibleChange() {
   selection_before_change_ = GetSelectedRange();
   text_before_change_ = GetText();
 }
 
 bool AutocompleteEditViewMac::OnAfterPossibleChange() {
-  NSRange new_selection(GetSelectedRange());
-  std::wstring new_text(GetText());
+  const NSRange new_selection(GetSelectedRange());
+  const std::wstring new_text(GetText());
   const size_t length = new_text.length();
 
-  bool selection_differs = !NSEqualRanges(new_selection,
-                                          selection_before_change_);
-  bool at_end_of_edit = (length == new_selection.location);
-  bool text_differs = (new_text != text_before_change_);
+  const bool selection_differs = !NSEqualRanges(new_selection,
+                                                selection_before_change_);
+  const bool at_end_of_edit = (length == new_selection.location);
+  const bool text_differs = (new_text != text_before_change_);
 
   // When the user has deleted text, we don't allow inline
   // autocomplete.  This is assumed if the text has gotten shorter AND
   // the selection has shifted towards the front of the text.  During
   // normal typing the text will almost always be shorter (as the new
   // input replaces the autocomplete suggestion), but in that case the
   // selection point will have moved towards the end of the text.
   // TODO(shess): In our implementation, we can catch -deleteBackward:
   // and other methods to provide positive knowledge that a delete
   // occured, rather than intuiting it from context.  Consider whether
   // that would be a stronger approach.
-  bool just_deleted_text =
+  const bool just_deleted_text =
       (length < text_before_change_.length() &&
        new_selection.location <= selection_before_change_.location);
 
-  bool something_changed = model_->OnAfterPossibleChange(new_text,
+  const bool something_changed = model_->OnAfterPossibleChange(new_text,
       selection_differs, text_differs, just_deleted_text, at_end_of_edit);
 
-  // TODO(shess): Restyle the text if something_changed.  Not fixing
-  // now because styling is currently broken.
+  // Restyle if the user changed something.
+  // TODO(shess): Does this need to diver deeper to avoid flashing?
+  // For instance, if the user types "/" after the hostname, will it
+  // show as HostTextColor() for an instant before being replaced by
+  // BaseTextColor().  This could probably be done by subclassing the
+  // cell and intercepting draw requests so that we draw the right
+  // thing every time.
+  // NOTE(shess): That kind of thing would also help with when the
+  // flashing from when the user's typing replaces the selection which
+  // is then re-created with the new autocomplete results.
+  if (something_changed) {
+    UpdateAndStyleText(new_text);
+    SetSelectedRange(new_selection);
+  }
 
   return something_changed;
 }
 
 void AutocompleteEditViewMac::OnUpOrDownKeyPressed(bool up, bool by_page) {
-  int count = by_page ? model_->result().size() : 1;
+  const int count = by_page ? model_->result().size() : 1;
   model_->OnUpOrDownKeyPressed(up ? -count : count);
 }
 void AutocompleteEditViewMac::OnEscapeKeyPressed() {
   model_->OnEscapeKeyPressed();
 }
 void AutocompleteEditViewMac::OnSetFocus(bool f) {
   model_->OnSetFocus(f);
 }
 void AutocompleteEditViewMac::OnKillFocus() {
   model_->OnKillFocus();
 }
 void AutocompleteEditViewMac::AcceptInput(
     WindowOpenDisposition disposition, bool for_drop) {
   model_->AcceptInput(disposition, for_drop);
 }
 
 void AutocompleteEditViewMac::FocusLocation() {
   // -makeFirstResponder: will select the entire field_.  If we're
   // already firstResponder, it's likely that we want to retain the
   // current selection.
   if (![field_ currentEditor]) {
     [[field_ window] makeFirstResponder:field_];
+    DCHECK_EQ([field_ currentEditor], [[field_ window] firstResponder]);
   }
 }
 
 @implementation AutocompleteFieldDelegate
 
 - initWithEditView:(AutocompleteEditViewMac*)view {
   self = [super init];
   if (self) {
     edit_view_ = view;
   }
@@ skipping 55 matching lines @@
 }
 
 - (void)controlTextDidEndEditing:(NSNotification*)aNotification {
   edit_view_->OnKillFocus();
 
   // TODO(shess): Figure out where the selection belongs.  On GTK,
   // it's set to the start of the text.
 }
 
 @end