Fix bug where the autocomplete text was being overridden by the user-entered text.

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"
@@ skipping 225 matching lines @@
     // TODO(shess): Figure out how this case is used, to make sure
     // we're getting the selection and popup right.
 
   } else {
     // TODO(shess): This corresponds to _win and _gtk, except those
     // guard it with a test for whether the security level changed.
     // But AFAICT, that can only change if the text changed, and that
     // code compares the toolbar_model_ security level with the local
     // security level.  Dig in and figure out why this isn't a no-op
     // that should go away.
-    UpdateAndStyleText(GetText());
+    EmphasizeURLComponents();
   }
 }
 
 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 14 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);
   // TODO(shess): TODO below from gtk.
   // TODO(deanm): something about selection / focus change here.
-  UpdateAndStyleText(display_text);
+  SetText(display_text);
   if (update_popup) {
     UpdatePopup();
   }
 }
 
 NSRange AutocompleteEditViewMac::GetSelectedRange() const {
   DCHECK([field_ currentEditor]);
   return [[field_ currentEditor] selectedRange];
 }
 
 void AutocompleteEditViewMac::SetSelectedRange(const NSRange range) {
   if (model_->has_focus()) {
     // TODO(shess): This should not be necessary.  Try to convert to
     // DCHECK(IsFirstResponder()).
     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) {
   DCHECK_LE(caret_pos, text.size());
-  UpdateAndStyleText(text);
-  SetSelectedRange(NSMakeRange(caret_pos, caret_pos));
+  SetTextAndSelectedRange(text, NSMakeRange(caret_pos, caret_pos));
 }
 
 void AutocompleteEditViewMac::SelectAll(bool reversed) {
   // 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.
 
   // TODO(shess): Verify that we should be stealing focus at this
   // point.
   SetSelectedRange(NSMakeRange(0, GetText().size()));
 }
 
 void AutocompleteEditViewMac::RevertAll() {
   ClosePopup();
   model_->Revert();
 
   // TODO(shess): This should be a no-op, the results from GetText()
   // could only get there via UpdateAndStyleText() in the first place.
   // Dig into where this code can be called from and see if this line
   // can be removed.
-  UpdateAndStyleText(GetText());
+  EmphasizeURLComponents();
   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) {
+void AutocompleteEditViewMac::SetText(const std::wstring& display_text) {
   NSString* ss = base::SysWideToNSString(display_text);
   NSMutableAttributedString* as =
       [[[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);
   const bool emphasize = model_->CurrentTextIsURL() && (parts.host.len > 0);
@@ skipping 31 matching lines @@
     } else {
       color = InsecureSchemeColor();
     }
     [as addAttribute:NSForegroundColorAttributeName value:color
                range:ComponentToNSRange(parts.scheme)];
   }
 
   [field_ setObjectValue:as];
 }
 
+void AutocompleteEditViewMac::SetTextAndSelectedRange(
+    const std::wstring& display_text, const NSRange range) {
+  SetText(display_text);
+  SetSelectedRange(range);
+}
+
+void AutocompleteEditViewMac::EmphasizeURLComponents() {
+  if ([field_ currentEditor]) {
+    SetTextAndSelectedRange(GetText(), GetSelectedRange());
+  } else {
+    SetText(GetText());
+  }
+}
+
 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();
   }
 
   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);
   DCHECK_LE(user_text_length, display_text.size());
-  SetSelectedRange(NSMakeRange(user_text_length, display_text.size()));
+  const NSRange range = NSMakeRange(user_text_length, display_text.size());
+  SetTextAndSelectedRange(display_text, range);
+
   return true;
 }
 
 void AutocompleteEditViewMac::OnRevertTemporaryText() {
-  UpdateAndStyleText(saved_temporary_text_);
+  SetTextAndSelectedRange(saved_temporary_text_, saved_temporary_selection_);
   saved_temporary_text_.clear();
-  SetSelectedRange(saved_temporary_selection_);
 }
 
 bool AutocompleteEditViewMac::IsFirstResponder() const {
   return [field_ currentEditor] != nil ? true : false;
 }
 
 void AutocompleteEditViewMac::OnBeforePossibleChange() {
   // We should only arrive here when the field is focussed.
   DCHECK(IsFirstResponder());
 
@@ skipping 35 matching lines @@
   // 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);
+    // TODO(shess) I believe that this call is needless duplication of
+    // effort.  As best I can tell, something_changed can only be true
+    // if |model_| called UpdatePopup(), which then updated us.  But
+    // the state involved seems substantial.
+    EmphasizeURLComponents();
   }
 
   return something_changed;
 }
 
 void AutocompleteEditViewMac::OnUpOrDownKeyPressed(bool up, bool by_page) {
   // We should only arrive here when the field is focussed.
   DCHECK(IsFirstResponder());
 
   const int count = by_page ? model_->result().size() : 1;
@@ skipping 119 matching lines @@
   // TODO(shess): Figure out where the selection belongs.  On GTK,
   // it's set to the start of the text.
 }
 
 // Signal that we've lost focus when the window resigns key.
 - (void)windowDidResignKey:(NSNotification*)notification {
   edit_view_->OnDidResignKey();
 }
 
 @end