Overhaul omnibox focus detection on Mac.

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"
 
+// Focus-handling between |field_| and |model_| is a bit subtle.
+// Other platforms detect change of focus, which is inconvenient
+// without subclassing NSTextField (even with a subclass, the use of a
+// field editor may complicate things).
+//
+// |model_| doesn't actually do anything when it gains focus, it just
+// initializes.  Visible activity happens only after the user edits.
+// NSTextField delegate receives messages around starting and ending
+// edits, so that sufcices to catch focus changes.  Since all calls
+// into |model_| start from AutocompleteEditViewMac, in the worst case
+// we can add code to sync up the sense of focus as needed.
+//
+// I've added DCHECK(IsFirstResponder()) in the places which I believe
+// should only be reachable when |field_| is being edited.  If these
+// fire, it probably means someone unexpected is calling into
+// |model_|.
+//
+// Other platforms don't appear to have the sense of "key window" that
+// Mac does (I believe their fields lose focus when the window loses
+// focus).  Rather than modifying focus outside the control's edit
+// scope, when the window resigns key the autocomplete popup is
+// closed.  |model_| still believes it has focus, and the popup will
+// be regenerated on the user's next edit.  That seems to match how
+// things work on other platforms.
+
 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
@@ skipping 68 matching lines @@
 // 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.
 }
 - initWithEditView:(AutocompleteEditViewMac*)view;
 - (void)windowDidResignKey:(NSNotification*)notification;
-- (void)windowDidBecomeKey:(NSNotification*)notification;
 @end
 
 AutocompleteEditViewMac::AutocompleteEditViewMac(
     AutocompleteEditController* controller,
     ToolbarModel* toolbar_model,
     Profile* profile,
     CommandUpdater* command_updater,
     NSTextField* field)
     : model_(new AutocompleteEditModel(this, controller, profile)),
       popup_view_(new AutocompletePopupViewMac(this, model_.get(), profile,
@@ skipping 13 matching lines @@
   // Needed so that editing doesn't lose the styling.
   [field_ setAllowsEditingTextAttributes:YES];
 
   // Track the window's key status for signalling focus changes to
   // |model_|.
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   [nc addObserver:edit_helper_
          selector:@selector(windowDidResignKey:) 
              name:NSWindowDidResignKeyNotification
            object:[field_ window]];
-  [nc addObserver:edit_helper_
-         selector:@selector(windowDidBecomeKey:) 
-             name:NSWindowDidBecomeKeyNotification
-           object:[field_ window]];
 }
 
 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 243 matching lines @@
   SetSelectedRange(NSMakeRange(user_text_length, display_text.size()));
   return true;
 }
 
 void AutocompleteEditViewMac::OnRevertTemporaryText() {
   UpdateAndStyleText(saved_temporary_text_);
   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());
+
   selection_before_change_ = GetSelectedRange();
   text_before_change_ = GetText();
 }
 
 bool AutocompleteEditViewMac::OnAfterPossibleChange() {
+  // We should only arrive here when the field is focussed.
+  DCHECK(IsFirstResponder());
+
   const NSRange new_selection(GetSelectedRange());
   const std::wstring new_text(GetText());
   const size_t length = new_text.length();
 
   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
@@ skipping 25 matching lines @@
   // 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) {
+  // We should only arrive here when the field is focussed.
+  DCHECK(IsFirstResponder());
+
   const int count = by_page ? model_->result().size() : 1;
   model_->OnUpOrDownKeyPressed(up ? -count : count);
 }
+
 void AutocompleteEditViewMac::OnEscapeKeyPressed() {
+  // We should only arrive here when the field is focussed.
+  DCHECK(IsFirstResponder());
+
   model_->OnEscapeKeyPressed();
 }
-void AutocompleteEditViewMac::OnSetFocus(bool f) {
-  // Only forward if we actually do have the focus.
-  if ([field_ currentEditor]) {
-    model_->OnSetFocus(f);
-  }
+
+void AutocompleteEditViewMac::OnWillBeginEditing() {
+  // We should only arrive here when the field is focussed.
+  DCHECK([field_ currentEditor]);
+
+  // TODO(shess): Having the control key depressed changes the desired
+  // TLD for autocomplete, which changes the results.  Not sure if we
+  // can detect that without subclassing NSTextField.
+  const bool controlDown = false;
+  model_->OnSetFocus(controlDown);
+
+  // Capture the current state.
+  OnBeforePossibleChange();
 }
-void AutocompleteEditViewMac::OnKillFocus() {
-  // TODO(shess): This would seem to be a job for |model_|.
+
+void AutocompleteEditViewMac::OnDidEndEditing() {
   ClosePopup();
 
   // Tell the model to reset itself.
   model_->OnKillFocus();
 }
+
+void AutocompleteEditViewMac::OnDidResignKey() {
+  ClosePopup();
+}
+
 void AutocompleteEditViewMac::AcceptInput(
     WindowOpenDisposition disposition, bool for_drop) {
+  // We should only arrive here when the field is focussed.
+  DCHECK([field_ currentEditor]);
+
   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]);
@@ skipping 43 matching lines @@
   }
 
   // Capture the state before the operation changes the content.
   // TODO(shess): Determine if this is always redundent WRT the call
   // in -controlTextDidChange:.
   edit_view_->OnBeforePossibleChange();
   return NO;
 }
 
 - (void)controlTextDidBeginEditing:(NSNotification*)aNotification {
-  edit_view_->OnSetFocus(false);
-
-  // Capture the current state.
-  edit_view_->OnBeforePossibleChange();
+  edit_view_->OnWillBeginEditing();
 }
 
 - (void)controlTextDidChange:(NSNotification*)aNotification {
   // Figure out what changed and notify the model_.
   edit_view_->OnAfterPossibleChange();
 
   // Then capture the new state.
   edit_view_->OnBeforePossibleChange();
 }
 
 - (BOOL)control:(NSControl*)control textShouldEndEditing:(NSText*)fieldEditor {
-  edit_view_->OnKillFocus();
+  edit_view_->OnDidEndEditing();
 
   return YES;
 
   // 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_->OnKillFocus();
-}
-
-// Signal that we may have regained focus.
-- (void)windowDidBecomeKey:(NSNotification*)notification {
-  edit_view_->OnSetFocus(false);
+  edit_view_->OnDidResignKey();
 }
 
 @end