Use Chrome facilities for omnibox state save and restore 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"
+
+namespace {
+
+// 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;
+  const bool has_focus;
+  const NSRange selection;
+};
+
+// Returns a lazily initialized property bag accessor for saving our
+// state in a TabContents.
+PropertyAccessor<AutocompleteEditViewMacState>* GetStateAccessor() {
+  static PropertyAccessor<AutocompleteEditViewMacState> state;

[pink (ping after 24hrs), 2009/05/08 21:18:26]

how does this work with multiple windows if there's only a single accessor? Am i
missing the obvious?

[Scott Hess - ex-Googler, 2009/05/08 22:50:21]

Oh, I hope I don't hurt myself, here ... brief summary is "This isn't obvious".

So, I believe that the property bag is a thing which maps unique identifiers to
data.  In this case, the bag itself is held by the TabContents instance.  The
accessor doesn't actually contain the data, it contains the unique identifier. 
SetProperty() on the accessor takes the bag and slots the input under the unique
id.  Similar for GetProperty().

I'm about 93% certain I could code GetStateAccessor() like:
  return *Singleton< PropertyAccessor<AutocompleteEditViewMacState> >::get();
but I'm frankly terrified of what it would mean for me to commit such a thing to
code.  

[pink (ping after 24hrs), 2009/05/11 13:50:11]

I figured it was something like this. Maybe a comment to this effect? Still
LGTM.

+  return &state;
+}
+
+// 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());
+}
+
+}  // 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.
 }
 - initWithEditView:(AutocompleteEditViewMac*)view;
@@ skipping 29 matching lines @@
   // back in the destructor.  Likewise for destroying the model before
   // this object.
   popup_view_.reset();
   model_.reset();
 
   // Disconnect field_ from edit_helper_ so that we don't get calls
   // after destruction.
   [field_ setDelegate:nil];
 }
 
-// TODO(shess): This is the minimal change which seems to unblock
-// getting the minimal Omnibox code checked in without making the
-// world worse.  Browser::TabSelectedAt() calls this when the tab
-// changes, but that is only wired up for Windows.  I do not yet
-// understand that code well enough to go for it.  Once wired up, then
-// code can be removed at:
-// [TabContentsController defocusLocationBar]
-// [TabStripController selectTabWithContents:...]
 void AutocompleteEditViewMac::SaveStateToTab(TabContents* tab) {
-  // TODO(shess): Actually save the state to the tab area.
+  DCHECK(tab);
 
-  // Drop the popup before we change to another tab.
-  ClosePopup();
+  NSRange range;
+  if (model_->has_focus()) {
+    range = GetSelectedRange();
+  } else {
+    // If we are not focussed, there is no selection.  Manufacture
+    // something reasonable in case it starts to matter in the future.
+    range = NSMakeRange(0, [[field_ stringValue] length]);
+  }
+
+  AutocompleteEditViewMacState state(model_->GetStateForTabSwitch(),
+                                     model_->has_focus(), range);
+  StoreStateToTab(tab, state);
+}
+
+void AutocompleteEditViewMac::Update(
+    const TabContents* tab_for_state_restoring) {
+  // TODO(shess): It seems like if the tab is non-NULL, then this code
+  // shouldn't need to be called at all.  When coded that way, I find
+  // that the field isn't always updated correctly.  Figure out why
+  // this is.  Maybe this method should be refactored into more
+  // specific cases.
+  const std::wstring text = toolbar_model_->GetText();
+  const bool user_visible = model_->UpdatePermanentText(text);
+
+  if (tab_for_state_restoring) {
+    RevertAll();
+
+    const AutocompleteEditViewMacState* state = 
+        GetStateFromTab(tab_for_state_restoring);
+    if (state) {
+      // 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];
+      }
+    }
+  } 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);
+  }
 }
 
 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
   // first place?  Make sure that case isn't being dropped on the
   // floor.
   if (!url.is_valid()) {
     return;
   }
 
   model_->SendOpenNotification(selected_line, keyword);
 
   if (disposition != NEW_BACKGROUND_TAB)
     RevertAll();  // Revert the box to its unedited state.
   controller_->OnAutocompleteAccept(url, disposition, transition,
                                     alternate_nav_url);
 }
 
 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());
+  if (update_popup) {
+    UpdatePopup();
+  }
+}
+
 NSRange AutocompleteEditViewMac::GetSelectedRange() const {
   DCHECK([field_ currentEditor]);
   return [[field_ currentEditor] selectedRange];
 }
 
 void AutocompleteEditViewMac::SetWindowTextAndCaretPos(const std::wstring& text,
                                                        size_t caret_pos) {
   UpdateAndStyleText(text, text.size());
 }
 
 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.
   UpdateAndStyleText(GetText(), 0);
 }
 
 void AutocompleteEditViewMac::RevertAll() {
   ClosePopup();
   model_->Revert();
 
   std::wstring tt = GetText();
-  UpdateAndStyleText(tt, tt.size());
+  UpdateAndStyleText(tt, 0);
   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
@@ skipping 16 matching lines @@
 
   url_parse::Parsed parts;
   AutocompleteInput::Parse(display_text, model_->GetDesiredTLD(),
                            &parts, NULL);
   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.end())];
+                                 (NSInteger)parts.host.len)];
   }
 
   // TODO(shess): GTK has this as a member var, figure out why.
   ToolbarModel::SecurityLevel scheme_security_level =
       toolbar_model_->GetSchemeSecurityLevel();
 
   // 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];
     } else {
       color = [NSColor blackColor];
     }
     [as addAttribute:NSForegroundColorAttributeName value:color
                range:NSMakeRange((NSInteger)parts.scheme.begin,
-                                 (NSInteger)parts.scheme.end())];
+                                 (NSInteger)parts.scheme.len)];
   }
 
   // TODO(shess): Check that this updates the model's sense of focus
   // correctly.
   [field_ setObjectValue:as];
   if (![field_ currentEditor]) {
     [field_ becomeFirstResponder];
-    DCHECK_EQ(field_, [[field_ window] firstResponder]);
+    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];
 }
 
@@ skipping 77 matching lines @@
 }
 void AutocompleteEditViewMac::OnKillFocus() {
   model_->OnKillFocus();
 }
 void AutocompleteEditViewMac::AcceptInput(
     WindowOpenDisposition disposition, bool for_drop) {
   model_->AcceptInput(disposition, for_drop);
 }
 
 void AutocompleteEditViewMac::FocusLocation() {
-  [[field_ window] makeFirstResponder:field_];
+  // -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_];
+  }
 }
 
 @implementation AutocompleteFieldDelegate
 
 - initWithEditView:(AutocompleteEditViewMac*)view {
   self = [super init];
   if (self) {
     edit_view_ = view;
   }
   return self;
@@ skipping 54 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