Refactor Textfield and AutocompleteEditViewViews.

chrome/browser/autocomplete/autocomplete_edit_view_views.cc

 // Copyright (c) 2011 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_views.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
@@ skipping 103 matching lines @@
     CommandUpdater* command_updater,
     bool popup_window_mode,
     const views::View* location_bar)
     : model_(new AutocompleteEditModel(this, controller, profile)),
       popup_view_(CreatePopupView(profile, location_bar)),
       controller_(controller),
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       popup_window_mode_(popup_window_mode),
       security_level_(ToolbarModel::NONE),
-      delete_was_pressed_(false),
+      ime_composing_before_change_(false),
       delete_at_end_pressed_(false) {
   set_border(views::Border::CreateEmptyBorder(kAutocompleteVerticalMargin, 0,
                                               kAutocompleteVerticalMargin, 0));
 }
 
 AutocompleteEditViewViews::~AutocompleteEditViewViews() {
   NotificationService::current()->Notify(
       NotificationType::AUTOCOMPLETE_EDIT_DESTROYED,
       Source<AutocompleteEditViewViews>(this),
       NotificationService::NoDetails());
@@ skipping 22 matching lines @@
 }
 
 void AutocompleteEditViewViews::SetBaseColor() {
   // TODO(oshima): Implment style change.
   NOTIMPLEMENTED();
 }
 
 bool AutocompleteEditViewViews::HandleAfterKeyEvent(
     const views::KeyEvent& event,
     bool handled) {
-  handling_key_press_ = false;
-  if (content_maybe_changed_by_key_press_)
-    OnAfterPossibleChange();
-
   if (event.key_code() == ui::VKEY_RETURN) {
     bool alt_held = event.IsAltDown();
     model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     handled = true;
   } else if (!handled && event.key_code() == ui::VKEY_ESCAPE) {
     // We can handle the Escape key if textfield did not handle it.
     // If it's not handled by us, then we need to propagate it up to the parent
     // widgets, so that Escape accelerator can still work.
     handled = model_->OnEscapeKeyPressed();
   } else if (event.key_code() == ui::VKEY_CONTROL) {
     // Omnibox2 can switch its contents while pressing a control key. To switch
     // the contents of omnibox2, we notify the AutocompleteEditModel class when
     // the control-key state is changed.
     model_->OnControlKeyChanged(true);
-  } else if (!text_changed_ && event.key_code() == ui::VKEY_DELETE &&
+  } else if (!handled && event.key_code() == ui::VKEY_DELETE &&
              event.IsShiftDown()) {
     // If shift+del didn't change the text, we let this delete an entry from
     // the popup.  We can't check to see if the IME handled it because even if
     // nothing is selected, the IME or the TextView still report handling it.
     if (model_->popup_model()->IsOpen())
       model_->popup_model()->TryDeletingCurrentItem();
   } else if (!handled && event.key_code() == ui::VKEY_UP) {
     model_->OnUpOrDownKeyPressed(-1);
     handled = true;
   } else if (!handled && event.key_code() == ui::VKEY_DOWN) {
@@ skipping 52 matching lines @@
   model_->OnWillKillFocus(NULL);
   // Close the popup.
   ClosePopup();
   // Tell the model to reset itself.
   model_->OnKillFocus();
   controller_->OnKillFocus();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditViewViews, views::View implementation:
-
-bool AutocompleteEditViewViews::OnMousePressed(
-    const views::MouseEvent& event) {
-  if (event.IsLeftMouseButton()) {
-    // Button press event may change the selection, we need to record the change
-    // and report it to |model_| later when button is released.
-    OnBeforePossibleChange();
-  }
-  // Pass the event through to TextfieldViews.
-  return false;
-}
-
 void AutocompleteEditViewViews::Layout() {
   gfx::Insets insets = GetInsets();
   textfield_->SetBounds(insets.left(), insets.top(),
                         width() - insets.width(),
                         height() - insets.height());
 }
 
 void AutocompleteEditViewViews::GetAccessibleState(
     ui::AccessibleViewState* state) {
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_LOCATION);
@@ skipping 191 matching lines @@
 
 void AutocompleteEditViewViews::OnRevertTemporaryText() {
   textfield_->SelectRange(saved_temporary_selection_);
   TextChanged();
 }
 
 void AutocompleteEditViewViews::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = GetText();
   textfield_->GetSelectedRange(&sel_before_change_);
+  ime_composing_before_change_ = textfield_->IsIMEComposing();
 }
 
 bool AutocompleteEditViewViews::OnAfterPossibleChange() {
-  // OnAfterPossibleChange should be called once per modification,
-  // and we should ignore if this is called while a key event is being handled
-  // because OnAfterPossibleChagne will be called after the key event is
-  // actually handled.
-  if (handling_key_press_) {
-    content_maybe_changed_by_key_press_ = true;
-    return false;
-  }
   ui::Range new_sel;
   textfield_->GetSelectedRange(&new_sel);
 
   size_t length = GetTextLength();
   bool at_end_of_edit = (new_sel.start() == length && new_sel.end() == length);
 
   // See if the text or selection have changed since OnBeforePossibleChange().
   string16 new_text = GetText();
-  text_changed_ = (new_text != text_before_change_);
+  bool text_changed = (new_text != text_before_change_) ||
+      (ime_composing_before_change_ != textfield_->IsIMEComposing());
   bool selection_differs =
       !((sel_before_change_.is_empty() && new_sel.is_empty()) ||
         sel_before_change_.EqualsIgnoringDirection(new_sel));
 
   // When the user has deleted text, we don't allow inline autocomplete.  Make
   // sure to not flag cases like selecting part of the text and then pasting
   // (or typing) the prefix of that selection.  (We detect these by making
   // sure the caret, which should be after any insertion, hasn't moved
   // forward of the old selection start.)
   bool just_deleted_text =
       (text_before_change_.length() > new_text.length()) &&
       (new_sel.start() <= sel_before_change_.GetMin());
 
-  delete_at_end_pressed_ = false;
-
   bool something_changed = model_->OnAfterPossibleChange(new_text,
-      selection_differs, text_changed_, just_deleted_text, at_end_of_edit);
+      selection_differs, text_changed, just_deleted_text, at_end_of_edit);
 
   // If only selection was changed, we don't need to call |model_|'s
   // OnChanged() method, which is called in TextChanged().
   // But we still need to call EmphasizeURLComponents() to make sure the text
   // attributes are updated correctly.
-  if (something_changed && text_changed_) {
+  if (something_changed && text_changed)
     TextChanged();
-  } else if (selection_differs) {
+  else if (selection_differs)
     EmphasizeURLComponents();
-  } else if (delete_was_pressed_ && at_end_of_edit) {
-    delete_at_end_pressed_ = true;
+  else if (delete_at_end_pressed_)
     model_->OnChanged();
-  }
-  delete_was_pressed_ = false;
 
   return something_changed;
 }
 
 gfx::NativeView AutocompleteEditViewViews::GetNativeView() const {
   return GetWidget()->GetNativeView();
 }
 
 CommandUpdater* AutocompleteEditViewViews::GetCommandUpdater() {
   return command_updater_;
@@ skipping 38 matching lines @@
                                       const NotificationDetails& details) {
   DCHECK(type == NotificationType::BROWSER_THEME_CHANGED);
   SetBaseColor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditViewViews, views::TextfieldController implementation:
 
 void AutocompleteEditViewViews::ContentsChanged(views::Textfield* sender,
                                                 const string16& new_contents) {
-  if (handling_key_press_)
-    content_maybe_changed_by_key_press_ = true;
 }
 
 bool AutocompleteEditViewViews::HandleKeyEvent(
     views::Textfield* textfield,
     const views::KeyEvent& event) {
-  delete_was_pressed_ = event.key_code() == ui::VKEY_DELETE;
-
-  // Reset |text_changed_| before passing the key event on to the text view.
-  text_changed_ = false;
-  OnBeforePossibleChange();
-  handling_key_press_ = true;
-  content_maybe_changed_by_key_press_ = false;
+  delete_at_end_pressed_ = false;
 
   if (event.key_code() == ui::VKEY_BACK) {
     // Checks if it's currently in keyword search mode.
     if (model_->is_keyword_hint() || model_->keyword().empty())
       return false;
     // If there is selection, let textfield handle the backspace.
-    if (!textfield_->GetSelectedText().empty())
+    if (textfield_->HasSelection())
       return false;
     // If not at the begining of the text, let textfield handle the backspace.
     if (textfield_->GetCursorPosition())
       return false;
     model_->ClearKeyword(GetText());
     return true;
   }
 
+  if (event.key_code() == ui::VKEY_DELETE && !event.IsAltDown()) {
+    delete_at_end_pressed_ =
+        (!textfield_->HasSelection() &&
+         textfield_->GetCursorPosition() == textfield_->text().length());
+  }
+
   return false;
 }
 
+void AutocompleteEditViewViews::OnBeforeUserAction(views::Textfield* sender) {
+  OnBeforePossibleChange();
+}
+
+void AutocompleteEditViewViews::OnAfterUserAction(views::Textfield* sender) {
+  OnAfterPossibleChange();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // AutocompleteEditViewViews, private:
 
 size_t AutocompleteEditViewViews::GetTextLength() const {
   // TODO(oshima): Support instant, IME.
   return textfield_->text().length();
 }
 
 void AutocompleteEditViewViews::EmphasizeURLComponents() {
   // TODO(oshima): Update URL visual style
@@ skipping 26 matching lines @@
 AutocompletePopupView* AutocompleteEditViewViews::CreatePopupView(
     Profile* profile,
     const View* location_bar) {
 #if defined(TOUCH_UI)
   return new TouchAutocompletePopupContentsView(
 #else
   return new AutocompletePopupContentsView(
 #endif
       gfx::Font(), this, model_.get(), profile, location_bar);
 }