Cleaning up ImeAdapter.java

content/public/android/java/src/org/chromium/content/browser/ImeAdapter.java

 // Copyright (c) 2012 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.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.text.Editable;
@@ skipping 478 matching lines @@
         nativePaste(mNativeImeAdapterAndroid);
         return true;
     }
 
     // This InputConnection is created by ContentView.onCreateInputConnection.
     // It then adapts android's IME to chrome's RenderWidgetHostView using the
     // native ImeAdapterAndroid via the outer class ImeAdapter.
     static public class AdapterInputConnection extends BaseInputConnection {
         private View mInternalView;
         private ImeAdapter mImeAdapter;
-        private Editable mEditable;
         private boolean mSingleLine;
 
         // Factory function.
         static public AdapterInputConnection getInstance(View view, ImeAdapter imeAdapter,
                 EditorInfo outAttrs) {
             return new AdapterInputConnection(view, imeAdapter, outAttrs);
         }
 
         /**
          * Updates the AdapterInputConnection's internal representation of the text
          * being edited and its selection and composition properties. The resulting
          * Editable is accessible through the getEditable() method.
          * If the text has not changed, this also calls updateSelection on the InputMethodManager.
          * @param text The String contents of the field being edited
          * @param selectionStart The character offset of the selection start, or the caret
          * position if there is no selection
          * @param selectionEnd The character offset of the selection end, or the caret
          * position if there is no selection
          * @param compositionStart The character offset of the composition start, or -1
          * if there is no composition
          * @param compositionEnd The character offset of the composition end, or -1
          * if there is no selection
          */
         public void setEditableText(String text, int selectionStart, int selectionEnd,
                 int compositionStart, int compositionEnd) {
 
-            if (mEditable == null) {
-                mEditable = Editable.Factory.getInstance().newEditable("");
-            }
+            Editable editable = getEditable();
 
-            int prevSelectionStart = Selection.getSelectionStart(mEditable);
-            int prevSelectionEnd = Selection.getSelectionEnd(mEditable);
-            int prevEditableLength = mEditable.length();
-            int prevCompositionStart = getComposingSpanStart(mEditable);
-            int prevCompositionEnd = getComposingSpanEnd(mEditable);
-            String prevText = mEditable.toString();
+            int prevSelectionStart = Selection.getSelectionStart(editable);
+            int prevSelectionEnd = Selection.getSelectionEnd(editable);
+            int prevEditableLength = editable.length();
+            int prevCompositionStart = getComposingSpanStart(editable);
+            int prevCompositionEnd = getComposingSpanEnd(editable);
+            String prevText = editable.toString();
 
             selectionStart = Math.min(selectionStart, text.length());
             selectionEnd = Math.min(selectionEnd, text.length());
             compositionStart = Math.min(compositionStart, text.length());
             compositionEnd = Math.min(compositionEnd, text.length());
 
             boolean textUnchanged = prevText.equals(text);
 
             if (textUnchanged
                     && prevSelectionStart == selectionStart && prevSelectionEnd == selectionEnd
                     && prevCompositionStart == compositionStart
                     && prevCompositionEnd == compositionEnd) {
                 // Nothing has changed; don't need to do anything
                 return;
             }
 
             // When a programmatic change has been made to the editable field, both the start
             // and end positions for the composition will equal zero. In this case we cancel the
             // active composition in the editor as this no longer is relevant.
             if (textUnchanged && compositionStart == 0 && compositionEnd == 0) {
                 cancelComposition();
             }
 
             if (!textUnchanged) {
-                mEditable.replace(0, mEditable.length(), text);
+                editable.replace(0, editable.length(), text);
             }
-            Selection.setSelection(mEditable, selectionStart, selectionEnd);
+            Selection.setSelection(editable, selectionStart, selectionEnd);
             super.setComposingRegion(compositionStart, compositionEnd);
 
             if (textUnchanged || prevText.equals("")) {
                 // updateSelection should be called when a manual selection change occurs.
                 // Should not be called if text is being entered else issues can occur
                 // e.g. backspace to undo autocorrection will not work with the default OSK.
                 getInputMethodManager().updateSelection(mInternalView,
                         selectionStart, selectionEnd, compositionStart, compositionEnd);
             }
         }
 
         @Override
-        public Editable getEditable() {
-            if (mEditable == null) {
-                mEditable = Editable.Factory.getInstance().newEditable("");
-                Selection.setSelection(mEditable, 0);
-            }
-            return mEditable;
-        }
-
-        @Override
         public boolean setComposingText(CharSequence text, int newCursorPosition) {
             super.setComposingText(text, newCursorPosition);
             return mImeAdapter.checkCompositionQueueAndCallNative(text.toString(),
                     newCursorPosition, false);
         }
 
         @Override
         public boolean commitText(CharSequence text, int newCursorPosition) {
             super.commitText(text, newCursorPosition);
             return mImeAdapter.checkCompositionQueueAndCallNative(text.toString(),
@@ skipping 31 matching lines @@
                 case android.R.id.paste:
                     return mImeAdapter.paste();
                 default:
                     return false;
             }
         }
 
         @Override
         public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) {
             ExtractedText et = new ExtractedText();
-            if (mEditable == null) {
-                et.text = "";
-            } else {
-                et.text = mEditable.toString();
-                et.partialEndOffset = mEditable.length();
-                et.selectionStart = Selection.getSelectionStart(mEditable);
-                et.selectionEnd = Selection.getSelectionEnd(mEditable);
-            }
+            Editable editable = getEditable();
+            et.text = editable.toString();
+            et.partialEndOffset = editable.length();
+            et.selectionStart = Selection.getSelectionStart(editable);
+            et.selectionEnd = Selection.getSelectionEnd(editable);
             et.flags = mSingleLine ? ExtractedText.FLAG_SINGLE_LINE : 0;
             return et;
         }
 
         @Override
         public boolean deleteSurroundingText(int leftLength, int rightLength) {
             if (!super.deleteSurroundingText(leftLength, rightLength)) {
                 return false;
             }
             return mImeAdapter.deleteSurroundingText(leftLength, rightLength);
@@ skipping 26 matching lines @@
                         editable.replace(selectionStart, selectionEnd,
                                 Character.toString((char)unicodeChar));
                     }
                 }
             }
             return super.sendKeyEvent(event);
         }
 
         @Override
         public boolean finishComposingText() {
-            if (mEditable == null
-                    || (getComposingSpanStart(mEditable) == getComposingSpanEnd(mEditable))) {
+            Editable editable = getEditable();
+            if (getComposingSpanStart(editable) == getComposingSpanEnd(editable)) {
                 return true;
             }
             super.finishComposingText();
             return mImeAdapter.checkCompositionQueueAndCallNative("", 0, true);
         }
 
         @Override
         public boolean setSelection(int start, int end) {
             if (start < 0 || end < 0) return true;
             super.setSelection(start, end);
@@ skipping 104 matching lines @@
 
     private native void nativeDeleteSurroundingText(int nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeUnselect(int nativeImeAdapterAndroid);
     private native void nativeSelectAll(int nativeImeAdapterAndroid);
     private native void nativeCut(int nativeImeAdapterAndroid);
     private native void nativeCopy(int nativeImeAdapterAndroid);
     private native void nativePaste(int nativeImeAdapterAndroid);
 }