Fix unicode bidi mirroring characters are not correctly mirrored in textfield

views/controls/textfield/native_textfield_win.cc

 // Copyright (c) 2010 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 "views/controls/textfield/native_textfield_win.h"
 
 #include <algorithm>
 
 #include "app/clipboard/clipboard.h"
 #include "app/clipboard/scoped_clipboard_writer.h"
@@ skipping 41 matching lines @@
     if (count == 0) {
       // We need to UpdateWindow() here instead of InvalidateRect() because, as
       // far as I can tell, the edit likes to synchronously erase its background
       // when unfreezing, thus requiring us to synchronously redraw if we don't
       // want flicker.
       edit_->UpdateWindow();
     }
   }
 }
 
+NativeTextfieldWin::ScopedSuspendUndo::ScopedSuspendUndo(
+    ITextDocument* text_object_model)
+    : text_object_model_(text_object_model) {
+  // Suspend Undo processing.
+  if (text_object_model_)
+    text_object_model_->Undo(tomSuspend, NULL);
+}
+
+NativeTextfieldWin::ScopedSuspendUndo::~ScopedSuspendUndo() {
+  // Resume Undo processing.
+  if (text_object_model_)
+    text_object_model_->Undo(tomResume, NULL);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // NativeTextfieldWin
 
 bool NativeTextfieldWin::did_load_library_ = false;
 
 NativeTextfieldWin::NativeTextfieldWin(Textfield* textfield)
     : textfield_(textfield),
       tracking_double_click_(false),
       double_click_time_(0),
       can_discard_mousemove_(false),
@@ skipping 235 matching lines @@
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   switch (command_id) {
     case IDS_APP_UNDO:       Undo();       break;
     case IDS_APP_CUT:        Cut();        break;
     case IDS_APP_COPY:       Copy();       break;
     case IDS_APP_PASTE:      Paste();      break;
     case IDS_APP_SELECT_ALL: SelectAll();  break;
     default:                 NOTREACHED(); break;
   }
-  OnAfterPossibleChange();
+  OnAfterPossibleChange(true);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTextfieldWin, private:
 
 void NativeTextfieldWin::OnChar(TCHAR ch, UINT repeat_count, UINT flags) {
   HandleKeystroke(GetCurrentMessage()->message, ch, repeat_count, flags);
 }
 
 void NativeTextfieldWin::OnContextMenu(HWND window, const POINT& point) {
@@ skipping 80 matching lines @@
 
       const int composition_size =
           ImmGetCompositionString(imm_context, GCS_COMPSTR, NULL, 0);
       if (composition_size >= 0)
         ime_composition_length_ = composition_size / sizeof(wchar_t);
 
       ImmReleaseContext(m_hWnd, imm_context);
     }
   }
 
-  OnAfterPossibleChange();
+  // If we allow OnAfterPossibleChange() to redraw the text, it will do this by
+  // setting the edit's text directly, which can cancel the current IME
+  // composition or cause other adverse affects. So we set |should_redraw_text|
+  // to false.
+  OnAfterPossibleChange(false);
   return result;
 }
 
 LRESULT NativeTextfieldWin::OnImeEndComposition(UINT message,
                                                 WPARAM wparam,
                                                 LPARAM lparam) {
   // Bug 11863: Korean IMEs send a WM_IME_ENDCOMPOSITION message without
   // sending any WM_IME_COMPOSITION messages when a user deletes all
   // composition characters, i.e. a composition string becomes empty. To handle
   // this case, we need to update the find results when a composition is
@@ skipping 37 matching lines @@
 
     case VK_DELETE:
     case 'X':
       if ((flags & KF_ALTDOWN) ||
           (GetKeyState((key == 'X') ? VK_CONTROL : VK_SHIFT) >= 0))
         break;
       if (GetKeyState((key == 'X') ? VK_SHIFT : VK_CONTROL) >= 0) {
         ScopedFreeze freeze(this, GetTextObjectModel());
         OnBeforePossibleChange();
         Cut();
-        OnAfterPossibleChange();
+        OnAfterPossibleChange(true);
       }
       return;
 
     case 'C':
       if ((flags & KF_ALTDOWN) || (GetKeyState(VK_CONTROL) >= 0))
         break;
       if (GetKeyState(VK_SHIFT) >= 0)
         Copy();
       return;
 
     case VK_INSERT:
       // Ignore insert by itself, so we don't turn overtype mode on/off.
       if (!(flags & KF_ALTDOWN) && (GetKeyState(VK_SHIFT) >= 0) &&
           (GetKeyState(VK_CONTROL) >= 0))
         return;
     case 'V':
       if ((flags & KF_ALTDOWN) ||
           (GetKeyState((key == 'V') ? VK_CONTROL : VK_SHIFT) >= 0))
         break;
       if (GetKeyState((key == 'V') ? VK_SHIFT : VK_CONTROL) >= 0) {
         ScopedFreeze freeze(this, GetTextObjectModel());
         OnBeforePossibleChange();
         Paste();
-        OnAfterPossibleChange();
+        OnAfterPossibleChange(true);
       }
       return;
 
     case 0xbb:  // Ctrl-'='.  Triggers subscripting, even in plain text mode.
                 // We don't use VK_OEM_PLUS in case the macro isn't defined.
                 // (e.g., we don't have this symbol in embeded environment).
       return;
 
     case VK_PROCESSKEY:
       // This key event is consumed by an IME.
@@ skipping 10 matching lines @@
 void NativeTextfieldWin::OnLButtonDblClk(UINT keys, const CPoint& point) {
   // Save the double click info for later triple-click detection.
   tracking_double_click_ = true;
   double_click_point_ = point;
   double_click_time_ = GetCurrentMessage()->time;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONDBLCLK, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, false), point.y));
-  OnAfterPossibleChange();
+  OnAfterPossibleChange(true);
 }
 
 void NativeTextfieldWin::OnLButtonDown(UINT keys, const CPoint& point) {
   // Check for triple click, then reset tracker.  Should be safe to subtract
   // double_click_time_ from the current message's time even if the timer has
   // wrapped in between.
   const bool is_triple_click = tracking_double_click_ &&
       win_util::IsDoubleClick(double_click_point_, point,
                               GetCurrentMessage()->time - double_click_time_);
   tracking_double_click_ = false;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONDOWN, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, is_triple_click),
                            point.y));
-  OnAfterPossibleChange();
+  OnAfterPossibleChange(true);
 }
 
 void NativeTextfieldWin::OnLButtonUp(UINT keys, const CPoint& point) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONUP, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, false), point.y));
-  OnAfterPossibleChange();
+  OnAfterPossibleChange(true);
 }
 
 void NativeTextfieldWin::OnMouseLeave() {
   SetContainsMouse(false);
 }
 
 LRESULT NativeTextfieldWin::OnMouseWheel(UINT message, WPARAM w_param,
                                          LPARAM l_param) {
   // Reroute the mouse-wheel to the window under the mouse pointer if
   // applicable.
@@ skipping 45 matching lines @@
     // behaves strangely when the cursor is dragged vertically: if the cursor
     // is in the middle of the text, drags inside the clip rect do nothing,
     // and drags outside the clip rect act as if the cursor jumped to the
     // left edge of the text.  When the cursor is at the right edge, drags of
     // just a few pixels vertically end up selecting the "phantom newline"...
     // sometimes.
     RECT r;
     GetRect(&r);
     DefWindowProc(WM_MOUSEMOVE, keys,
                   MAKELPARAM(point.x, (r.bottom - r.top) / 2));
-    OnAfterPossibleChange();
+    OnAfterPossibleChange(true);
   }
 }
 
 int NativeTextfieldWin::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
   content_insets_.Set(0, 0, 0, 0);
   if (textfield_->draw_border())
     content_insets_ = CalculateInsets();
   if (w_param) {
     NCCALCSIZE_PARAMS* nc_params =
         reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param);
@@ skipping 156 matching lines @@
       // layout of the first LTR character in input text. Such keyboard layout
       // change behavior is surprising and inconsistent with keyboard behavior
       // elsewhere, so reset the layout in this case.
       HKL layout = GetKeyboardLayout(0);
       DefWindowProc(message, key, MAKELPARAM(repeat_count, flags));
       ActivateKeyboardLayout(layout, KLF_REORDER);
     } else {
       DefWindowProc(message, key, MAKELPARAM(repeat_count, flags));
     }
 
-    OnAfterPossibleChange();
+    // CRichEditCtrl automatically turns on IMF_AUTOKEYBOARD when the user
+    // inputs an RTL character, making it difficult for the user to control
+    // what language is set as they type. Force this off to make the edit's
+    // behavior more stable.
+    const int lang_options = SendMessage(EM_GETLANGOPTIONS, 0, 0);
+    if (lang_options & IMF_AUTOKEYBOARD)
+      SendMessage(EM_SETLANGOPTIONS, 0, lang_options & ~IMF_AUTOKEYBOARD);
+
+    OnAfterPossibleChange(true);
   }
 }
 
 void NativeTextfieldWin::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = GetText();
 }
 
-void NativeTextfieldWin::OnAfterPossibleChange() {
+void NativeTextfieldWin::OnAfterPossibleChange(bool should_redraw_text) {
   // Prevent the user from selecting the "phantom newline" at the end of the
   // edit.  If they try, we just silently move the end of the selection back to
   // the end of the real text.
   CHARRANGE new_sel;
   GetSel(new_sel);
   const int length = GetTextLength();
   if (new_sel.cpMax > length) {
     new_sel.cpMax = length;
     if (new_sel.cpMin > length)
       new_sel.cpMin = length;
     SetSel(new_sel);
   }
 
   std::wstring new_text(GetText());
   if (new_text != text_before_change_) {
     if (ime_discard_composition_ && ime_composition_start_ >= 0 &&
         ime_composition_length_ > 0) {
       // A string retrieved with a GetText() call contains a string being
       // composed by an IME. We remove the composition string from this search
       // string.
       new_text.erase(ime_composition_start_, ime_composition_length_);
       ime_composition_start_ = 0;
       ime_composition_length_ = 0;
       if (new_text.empty())
         return;
     }
     textfield_->SyncText();
     if (textfield_->GetController())
       textfield_->GetController()->ContentsChanged(textfield_, new_text);
+
+    if (should_redraw_text) {
+      CHARRANGE original_sel;
+      GetSel(original_sel);
+      std::wstring text = GetText();
+      ScopedSuspendUndo suspend_undo(GetTextObjectModel());
+
+      SelectAll();
+      ReplaceSel(reinterpret_cast<LPCTSTR>(text.c_str()), true);
+      SetSel(original_sel);
+    }
   }
 }
 
 LONG NativeTextfieldWin::ClipXCoordToVisibleText(LONG x,
                                                  bool is_triple_click) const {
   // Clip the X coordinate to the left edge of the text.  Careful:
   // PosFromChar(0) may return a negative X coordinate if the beginning of the
   // text has scrolled off the edit, so don't go past the clip rect's edge.
   PARAFORMAT2 pf2;
   GetParaFormat(pf2);
@@ skipping 96 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTextfieldWrapper, public:
 
 // static
 NativeTextfieldWrapper* NativeTextfieldWrapper::CreateWrapper(
     Textfield* field) {
   return new NativeTextfieldWin(field);
 }
 
 }  // namespace views