The Tor Browser: mobile/android/base/GeckoEditable.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoEditable.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoEditable.java

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 package org.mozilla.gecko;
 import org.mozilla.gecko.gfx.InputConnectionHandler;
 import org.mozilla.gecko.gfx.LayerView;
 import org.mozilla.gecko.util.GeckoEventListener;
 import org.mozilla.gecko.util.ThreadUtils;
 import org.mozilla.gecko.util.ThreadUtils.AssertBehavior;
 import org.json.JSONObject;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.text.Editable;
 import android.text.InputFilter;
 import android.text.Selection;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.SpannableStringBuilder;
 import android.text.Spanned;
 import android.text.TextPaint;
 import android.text.TextUtils;
 import android.text.style.CharacterStyle;
 import android.util.Log;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.Semaphore;
 // interface for the IC thread
 interface GeckoEditableClient {
     void sendEvent(GeckoEvent event);
     Editable getEditable();
     void setUpdateGecko(boolean update);
     void setSuppressKeyUp(boolean suppress);
     Handler getInputConnectionHandler();
     boolean setInputConnectionHandler(Handler handler);
 }
 /* interface for the Editable to listen to the Gecko thread
    and also for the IC thread to listen to the Editable */
 interface GeckoEditableListener {
     // IME notification type for notifyIME(), corresponding to NotificationToIME enum in Gecko
     final int NOTIFY_IME_OPEN_VKB = -2;
     final int NOTIFY_IME_REPLY_EVENT = -1;
     final int NOTIFY_IME_OF_FOCUS = 1;
     final int NOTIFY_IME_OF_BLUR = 2;
     final int NOTIFY_IME_TO_COMMIT_COMPOSITION = 7;
     final int NOTIFY_IME_TO_CANCEL_COMPOSITION = 8;
     // IME enabled state for notifyIMEContext()
     final int IME_STATE_DISABLED = 0;
     final int IME_STATE_ENABLED = 1;
     final int IME_STATE_PASSWORD = 2;
     final int IME_STATE_PLUGIN = 3;
     void notifyIME(int type);
     void notifyIMEContext(int state, String typeHint,
                           String modeHint, String actionHint);
     void onSelectionChange(int start, int end);
     void onTextChange(String text, int start, int oldEnd, int newEnd);
 }
 /*
    GeckoEditable implements only some functions of Editable
    The field mText contains the actual underlying
    SpannableStringBuilder/Editable that contains our text.
 */
 final class GeckoEditable
         implements InvocationHandler, Editable,
                    GeckoEditableClient, GeckoEditableListener, GeckoEventListener {
     private static final boolean DEBUG = false;
     private static final String LOGTAG = "GeckoEditable";
     // Filters to implement Editable's filtering functionality
     private InputFilter[] mFilters;
     private final SpannableStringBuilder mText;
     private final SpannableStringBuilder mChangedText;
     private final Editable mProxy;
     private final ActionQueue mActionQueue;
     // mIcRunHandler is the Handler that currently runs Gecko-to-IC Runnables
     // mIcPostHandler is the Handler to post Gecko-to-IC Runnables to
     // The two can be different when switching from one handler to another
     private Handler mIcRunHandler;
     private Handler mIcPostHandler;
     private GeckoEditableListener mListener;
     private int mSavedSelectionStart;
     private volatile int mGeckoUpdateSeqno;
     private int mIcUpdateSeqno;
     private int mLastIcUpdateSeqno;
     private boolean mUpdateGecko;
     private boolean mFocused; // Used by IC thread
     private boolean mGeckoFocused; // Used by Gecko thread
     private volatile boolean mSuppressCompositions;
     private volatile boolean mSuppressKeyUp;
     /* An action that alters the Editable
        Each action corresponds to a Gecko event. While the Gecko event is being sent to the Gecko
        thread, the action stays on top of mActions queue. After the Gecko event is processed and
        replied, the action is removed from the queue
     */
     private static final class Action {
         // For input events (keypress, etc.); use with IME_SYNCHRONIZE
         static final int TYPE_EVENT = 0;
         // For Editable.replace() call; use with IME_REPLACE_TEXT
         static final int TYPE_REPLACE_TEXT = 1;
         /* For Editable.setSpan(Selection...) call; use with IME_SYNCHRONIZE
            Note that we don't use this with IME_SET_SELECTION because we don't want to update the
            Gecko selection at the point of this action. The Gecko selection is updated only after
            IC has updated its selection (during IME_SYNCHRONIZE reply) */
         static final int TYPE_SET_SELECTION = 2;
         // For Editable.setSpan() call; use with IME_SYNCHRONIZE
         static final int TYPE_SET_SPAN = 3;
         // For Editable.removeSpan() call; use with IME_SYNCHRONIZE
         static final int TYPE_REMOVE_SPAN = 4;
         // For focus events (in notifyIME); use with IME_ACKNOWLEDGE_FOCUS
         static final int TYPE_ACKNOWLEDGE_FOCUS = 5;
         // For switching handler; use with IME_SYNCHRONIZE
         static final int TYPE_SET_HANDLER = 6;
         final int mType;
         int mStart;
         int mEnd;
         CharSequence mSequence;
         Object mSpanObject;
         int mSpanFlags;
         boolean mShouldUpdate;
         Handler mHandler;
         Action(int type) {
             mType = type;
         }
         static Action newReplaceText(CharSequence text, int start, int end) {
             if (start < 0 || start > end) {
                 throw new IllegalArgumentException(
                     "invalid replace text offsets: " + start + " to " + end);
             }
             final Action action = new Action(TYPE_REPLACE_TEXT);
             action.mSequence = text;
             action.mStart = start;
             action.mEnd = end;
             return action;
         }
         static Action newSetSelection(int start, int end) {
             // start == -1 when the start offset should remain the same
             // end == -1 when the end offset should remain the same
             if (start < -1 || end < -1) {
                 throw new IllegalArgumentException(
                     "invalid selection offsets: " + start + " to " + end);
             }
             final Action action = new Action(TYPE_SET_SELECTION);
             action.mStart = start;
             action.mEnd = end;
             return action;
         }
         static Action newSetSpan(Object object, int start, int end, int flags) {
             if (start < 0 || start > end) {
                 throw new IllegalArgumentException(
                     "invalid span offsets: " + start + " to " + end);
             }
             final Action action = new Action(TYPE_SET_SPAN);
             action.mSpanObject = object;
             action.mStart = start;
             action.mEnd = end;
             action.mSpanFlags = flags;
             return action;
         }
         static Action newSetHandler(Handler handler) {
             final Action action = new Action(TYPE_SET_HANDLER);
             action.mHandler = handler;
             return action;
         }
     }
     /* Queue of editing actions sent to Gecko thread that
        the Gecko thread has not responded to yet */
     private final class ActionQueue {
         private final ConcurrentLinkedQueue<Action> mActions;
         private final Semaphore mActionsActive;
         private KeyCharacterMap mKeyMap;
         ActionQueue() {
             mActions = new ConcurrentLinkedQueue<Action>();
             mActionsActive = new Semaphore(1);
         }
         void offer(Action action) {
             if (DEBUG) {
                 assertOnIcThread();
                 Log.d(LOGTAG, "offer: Action(" +
                               getConstantName(Action.class, "TYPE_", action.mType) + ")");
             }
             /* Events don't need update because they generate text/selection
                notifications which will do the updating for us */
             if (action.mType != Action.TYPE_EVENT &&
                 action.mType != Action.TYPE_ACKNOWLEDGE_FOCUS &&
                 action.mType != Action.TYPE_SET_HANDLER) {
                 action.mShouldUpdate = mUpdateGecko;
             }
             if (mActions.isEmpty()) {
                 mActionsActive.acquireUninterruptibly();
                 mActions.offer(action);
             } else synchronized(this) {
                 // tryAcquire here in case Gecko thread has just released it
                 mActionsActive.tryAcquire();
                 mActions.offer(action);
             }
             switch (action.mType) {
             case Action.TYPE_EVENT:
             case Action.TYPE_SET_SELECTION:
             case Action.TYPE_SET_SPAN:
             case Action.TYPE_REMOVE_SPAN:
             case Action.TYPE_SET_HANDLER:
                 GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
                         GeckoEvent.ImeAction.IME_SYNCHRONIZE));
                 break;
             case Action.TYPE_REPLACE_TEXT:
                 // try key events first
                 sendCharKeyEvents(action);
                 GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEReplaceEvent(
                         action.mStart, action.mEnd, action.mSequence.toString()));
                 break;
             case Action.TYPE_ACKNOWLEDGE_FOCUS:
                 GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
                         GeckoEvent.ImeAction.IME_ACKNOWLEDGE_FOCUS));
                 break;
             }
             ++mIcUpdateSeqno;
         }
         private KeyEvent [] synthesizeKeyEvents(CharSequence cs) {
             try {
                 if (mKeyMap == null) {
                     mKeyMap = KeyCharacterMap.load(
                         Build.VERSION.SDK_INT < 11 ? KeyCharacterMap.ALPHA :
                                                      KeyCharacterMap.VIRTUAL_KEYBOARD);
                 }
             } catch (Exception e) {
                 // KeyCharacterMap.UnavailableExcepton is not found on Gingerbread;
                 // besides, it seems like HC and ICS will throw something other than
                 // KeyCharacterMap.UnavailableExcepton; so use a generic Exception here
                 return null;
             }
             KeyEvent [] keyEvents = mKeyMap.getEvents(cs.toString().toCharArray());
             if (keyEvents == null || keyEvents.length == 0) {
                 return null;
             }
             return keyEvents;
         }
         private void sendCharKeyEvents(Action action) {
             if (action.mSequence.length() == 0 ||
                 (action.mSequence instanceof Spannable &&
                 ((Spannable)action.mSequence).nextSpanTransition(
                     -1, Integer.MAX_VALUE, null) < Integer.MAX_VALUE)) {
                 // Spans are not preserved when we use key events,
                 // so we need the sequence to not have any spans
                 return;
             }
             KeyEvent [] keyEvents = synthesizeKeyEvents(action.mSequence);
             if (keyEvents == null) {
                 return;
             }
             for (KeyEvent event : keyEvents) {
                 if (KeyEvent.isModifierKey(event.getKeyCode())) {
                     continue;
                 }
                 if (event.getAction() == KeyEvent.ACTION_UP && mSuppressKeyUp) {
                     continue;
                 }
                 if (DEBUG) {
                     Log.d(LOGTAG, "sending: " + event);
                 }
                 GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEKeyEvent(event));
             }
         }
         void poll() {
             if (DEBUG) {
                 ThreadUtils.assertOnGeckoThread();
             }
             if (mActions.isEmpty()) {
                 throw new IllegalStateException("empty actions queue");
             }
             mActions.poll();
             // Don't bother locking if queue is not empty yet
             if (mActions.isEmpty()) {
                 synchronized(this) {
                     if (mActions.isEmpty()) {
                         mActionsActive.release();
                     }
                 }
             }
         }
         Action peek() {
             if (DEBUG) {
                 ThreadUtils.assertOnGeckoThread();
             }
             if (mActions.isEmpty()) {
                 throw new IllegalStateException("empty actions queue");
             }
             return mActions.peek();
         }
         void syncWithGecko() {
             if (DEBUG) {
                 assertOnIcThread();
             }
             if (mFocused && !mActions.isEmpty()) {
                 if (DEBUG) {
                     Log.d(LOGTAG, "syncWithGecko blocking on thread " +
                                   Thread.currentThread().getName());
                 }
                 mActionsActive.acquireUninterruptibly();
                 mActionsActive.release();
             } else if (DEBUG && !mFocused) {
                 Log.d(LOGTAG, "skipped syncWithGecko (no focus)");
             }
         }
         boolean isEmpty() {
             return mActions.isEmpty();
         }
     }
     GeckoEditable() {
         mActionQueue = new ActionQueue();
         mSavedSelectionStart = -1;
         mUpdateGecko = true;
         mText = new SpannableStringBuilder();
         mChangedText = new SpannableStringBuilder();
         final Class<?>[] PROXY_INTERFACES = { Editable.class };
         mProxy = (Editable)Proxy.newProxyInstance(
                 Editable.class.getClassLoader(),
                 PROXY_INTERFACES, this);
         LayerView v = GeckoAppShell.getLayerView();
         mListener = GeckoInputConnection.create(v, this);
         mIcRunHandler = mIcPostHandler = ThreadUtils.getUiHandler();
     }
     private boolean onIcThread() {
         return mIcRunHandler.getLooper() == Looper.myLooper();
     }
     private void assertOnIcThread() {
         ThreadUtils.assertOnThread(mIcRunHandler.getLooper().getThread(), AssertBehavior.THROW);
     }
     private void geckoPostToIc(Runnable runnable) {
         mIcPostHandler.post(runnable);
     }
     private void geckoUpdateGecko(final boolean force) {
         /* We do not increment the seqno here, but only check it, because geckoUpdateGecko is a
            request for update. If we incremented the seqno here, geckoUpdateGecko would have
            prevented other updates from occurring */
         final int seqnoWhenPosted = mGeckoUpdateSeqno;
         geckoPostToIc(new Runnable() {
             @Override
             public void run() {
                 mActionQueue.syncWithGecko();
                 if (seqnoWhenPosted == mGeckoUpdateSeqno) {
                     icUpdateGecko(force);
                 }
             }
         });
     }
     private Object getField(Object obj, String field, Object def) {
         try {
             return obj.getClass().getField(field).get(obj);
         } catch (Exception e) {
             return def;
         }
     }
     private void icUpdateGecko(boolean force) {
         // Skip if receiving a repeated request, or
         // if suppressing compositions during text selection.
         if ((!force && mIcUpdateSeqno == mLastIcUpdateSeqno) ||
             mSuppressCompositions) {
             if (DEBUG) {
                 Log.d(LOGTAG, "icUpdateGecko() skipped");
             }
             return;
         }
         mLastIcUpdateSeqno = mIcUpdateSeqno;
         mActionQueue.syncWithGecko();
         if (DEBUG) {
             Log.d(LOGTAG, "icUpdateGecko()");
         }
         final int selStart = mText.getSpanStart(Selection.SELECTION_START);
         final int selEnd = mText.getSpanEnd(Selection.SELECTION_END);
         int composingStart = mText.length();
         int composingEnd = 0;
         Object[] spans = mText.getSpans(0, composingStart, Object.class);
         for (Object span : spans) {
             if ((mText.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
                 composingStart = Math.min(composingStart, mText.getSpanStart(span));
                 composingEnd = Math.max(composingEnd, mText.getSpanEnd(span));
             }
         }
         if (DEBUG) {
             Log.d(LOGTAG, " range = " + composingStart + "-" + composingEnd);
             Log.d(LOGTAG, " selection = " + selStart + "-" + selEnd);
         }
         if (composingStart >= composingEnd) {
             if (selStart >= 0 && selEnd >= 0) {
                 GeckoAppShell.sendEventToGecko(
                         GeckoEvent.createIMESelectEvent(selStart, selEnd));
             } else {
                 GeckoAppShell.sendEventToGecko(GeckoEvent.createIMEEvent(
                         GeckoEvent.ImeAction.IME_REMOVE_COMPOSITION));
             }
             return;
         }
         if (selEnd >= composingStart && selEnd <= composingEnd) {
             GeckoAppShell.sendEventToGecko(GeckoEvent.createIMERangeEvent(
                     selEnd - composingStart, selEnd - composingStart,
                     GeckoEvent.IME_RANGE_CARETPOSITION, 0, 0, false, 0, 0, 0));
         }
         int rangeStart = composingStart;
         TextPaint tp = new TextPaint();
         TextPaint emptyTp = new TextPaint();
         // set initial foreground color to 0, because we check for tp.getColor() == 0
         // below to decide whether to pass a foreground color to Gecko
         emptyTp.setColor(0);
         do {
             int rangeType, rangeStyles = 0, rangeLineStyle = GeckoEvent.IME_RANGE_LINE_NONE;
             boolean rangeBoldLine = false;
             int rangeForeColor = 0, rangeBackColor = 0, rangeLineColor = 0;
             int rangeEnd = mText.nextSpanTransition(rangeStart, composingEnd, Object.class);
             if (selStart > rangeStart && selStart < rangeEnd) {
                 rangeEnd = selStart;
             } else if (selEnd > rangeStart && selEnd < rangeEnd) {
                 rangeEnd = selEnd;
             }
             CharacterStyle[] styleSpans =
                     mText.getSpans(rangeStart, rangeEnd, CharacterStyle.class);
             if (DEBUG) {
                 Log.d(LOGTAG, " found " + styleSpans.length + " spans @ " +
                               rangeStart + "-" + rangeEnd);
             }
             if (styleSpans.length == 0) {
                 rangeType = (selStart == rangeStart && selEnd == rangeEnd)
                             ? GeckoEvent.IME_RANGE_SELECTEDRAWTEXT
                             : GeckoEvent.IME_RANGE_RAWINPUT;
             } else {
                 rangeType = (selStart == rangeStart && selEnd == rangeEnd)
                             ? GeckoEvent.IME_RANGE_SELECTEDCONVERTEDTEXT
                             : GeckoEvent.IME_RANGE_CONVERTEDTEXT;
                 tp.set(emptyTp);
                 for (CharacterStyle span : styleSpans) {
                     span.updateDrawState(tp);
                 }
                 int tpUnderlineColor = 0;
                 float tpUnderlineThickness = 0.0f;
                 // These TextPaint fields only exist on Android ICS+ and are not in the SDK
                 if (Build.VERSION.SDK_INT >= 14) {
                     tpUnderlineColor = (Integer)getField(tp, "underlineColor", 0);
                     tpUnderlineThickness = (Float)getField(tp, "underlineThickness", 0.0f);
                 }
                 if (tpUnderlineColor != 0) {
                     rangeStyles |= GeckoEvent.IME_RANGE_UNDERLINE | GeckoEvent.IME_RANGE_LINECOLOR;
                     rangeLineColor = tpUnderlineColor;
                     // Approximately translate underline thickness to what Gecko understands
                     if (tpUnderlineThickness <= 0.5f) {
                         rangeLineStyle = GeckoEvent.IME_RANGE_LINE_DOTTED;
                     } else {
                         rangeLineStyle = GeckoEvent.IME_RANGE_LINE_SOLID;
                         if (tpUnderlineThickness >= 2.0f) {
                             rangeBoldLine = true;
                         }
                     }
                 } else if (tp.isUnderlineText()) {
                     rangeStyles |= GeckoEvent.IME_RANGE_UNDERLINE;
                     rangeLineStyle = GeckoEvent.IME_RANGE_LINE_SOLID;
                 }
                 if (tp.getColor() != 0) {
                     rangeStyles |= GeckoEvent.IME_RANGE_FORECOLOR;
                     rangeForeColor = tp.getColor();
                 }
                 if (tp.bgColor != 0) {
                     rangeStyles |= GeckoEvent.IME_RANGE_BACKCOLOR;
                     rangeBackColor = tp.bgColor;
                 }
             }
             GeckoAppShell.sendEventToGecko(GeckoEvent.createIMERangeEvent(
                     rangeStart - composingStart, rangeEnd - composingStart,
                     rangeType, rangeStyles, rangeLineStyle, rangeBoldLine,
                     rangeForeColor, rangeBackColor, rangeLineColor));
             rangeStart = rangeEnd;
             if (DEBUG) {
                 Log.d(LOGTAG, " added " + rangeType +
                               " : " + Integer.toHexString(rangeStyles) +
                               " : " + Integer.toHexString(rangeForeColor) +
                               " : " + Integer.toHexString(rangeBackColor));
             }
         } while (rangeStart < composingEnd);
         GeckoAppShell.sendEventToGecko(GeckoEvent.createIMECompositionEvent(
                 composingStart, composingEnd));
     }
     // GeckoEditableClient interface
     @Override
     public void sendEvent(final GeckoEvent event) {
         if (DEBUG) {
             assertOnIcThread();
             Log.d(LOGTAG, "sendEvent(" + event + ")");
         }
         /*
            We are actually sending two events to Gecko here,
 . Event from the event parameter (key event, etc.)
 . Sync event from the mActionQueue.offer call
            The first event is a normal GeckoEvent that does not reply back to us,
            the second sync event will have a reply, during which we see that there is a pending
            event-type action, and update the selection/composition/etc. accordingly.
         */
         GeckoAppShell.sendEventToGecko(event);
         mActionQueue.offer(new Action(Action.TYPE_EVENT));
     }
     @Override
     public Editable getEditable() {
         if (!onIcThread()) {
             // Android may be holding an old InputConnection; ignore
             if (DEBUG) {
                 Log.i(LOGTAG, "getEditable() called on non-IC thread");
             }
             return null;
         }
         return mProxy;
     }
     @Override
     public void setUpdateGecko(boolean update) {
         if (!onIcThread()) {
             // Android may be holding an old InputConnection; ignore
             if (DEBUG) {
                 Log.i(LOGTAG, "setUpdateGecko() called on non-IC thread");
             }
             return;
         }
         if (update) {
             icUpdateGecko(false);
         }
         mUpdateGecko = update;
     }
     @Override
     public void setSuppressKeyUp(boolean suppress) {
         if (DEBUG) {
             // only used by key event handler
             ThreadUtils.assertOnUiThread();
         }
         // Suppress key up event generated as a result of
         // translating characters to key events
         mSuppressKeyUp = suppress;
     }
     @Override
     public Handler getInputConnectionHandler() {
         // Can be called from either UI thread or IC thread;
         // care must be taken to avoid race conditions
         return mIcRunHandler;
     }
     @Override
     public boolean setInputConnectionHandler(Handler handler) {
         if (handler == mIcPostHandler) {
             return true;
         }
         if (!mFocused) {
             return false;
         }
         if (DEBUG) {
             assertOnIcThread();
         }
         // There are three threads at this point: Gecko thread, old IC thread, and new IC
         // thread, and we want to safely switch from old IC thread to new IC thread.
         // We first send a TYPE_SET_HANDLER action to the Gecko thread; this ensures that
         // the Gecko thread is stopped at a known point. At the same time, the old IC
         // thread blocks on the action; this ensures that the old IC thread is stopped at
         // a known point. Finally, inside the Gecko thread, we post a Runnable to the old
         // IC thread; this Runnable switches from old IC thread to new IC thread. We
         // switch IC thread on the old IC thread to ensure any pending Runnables on the
         // old IC thread are processed before we switch over. Inside the Gecko thread, we
         // also post a Runnable to the new IC thread; this Runnable blocks until the
         // switch is complete; this ensures that the new IC thread won't accept
         // InputConnection calls until after the switch.
         mActionQueue.offer(Action.newSetHandler(handler));
         mActionQueue.syncWithGecko();
         return true;
     }
     private void geckoSetIcHandler(final Handler newHandler) {
         geckoPostToIc(new Runnable() { // posting to old IC thread
             @Override
             public void run() {
                 synchronized (newHandler) {
                     mIcRunHandler = newHandler;
                     newHandler.notify();
                 }
             }
         });
         // At this point, all future Runnables should be posted to the new IC thread, but
         // we don't switch mIcRunHandler yet because there may be pending Runnables on the
         // old IC thread still waiting to run.
         mIcPostHandler = newHandler;
         geckoPostToIc(new Runnable() { // posting to new IC thread
             @Override
             public void run() {
                 synchronized (newHandler) {
                     while (mIcRunHandler != newHandler) {
                         try {
                             newHandler.wait();
                         } catch (InterruptedException e) {
                         }
                     }
                 }
             }
         });
     }
     // GeckoEditableListener interface
     private void geckoActionReply() {
         if (DEBUG) {
             // GeckoEditableListener methods should all be called from the Gecko thread
             ThreadUtils.assertOnGeckoThread();
         }
         final Action action = mActionQueue.peek();
         if (DEBUG) {
             Log.d(LOGTAG, "reply: Action(" +
                           getConstantName(Action.class, "TYPE_", action.mType) + ")");
         }
         switch (action.mType) {
         case Action.TYPE_SET_SELECTION:
             final int len = mText.length();
             final int curStart = Selection.getSelectionStart(mText);
             final int curEnd = Selection.getSelectionEnd(mText);
             // start == -1 when the start offset should remain the same
             // end == -1 when the end offset should remain the same
             final int selStart = Math.min(action.mStart < 0 ? curStart : action.mStart, len);
             final int selEnd = Math.min(action.mEnd < 0 ? curEnd : action.mEnd, len);
             if (selStart < action.mStart || selEnd < action.mEnd) {
                 Log.w(LOGTAG, "IME sync error: selection out of bounds");
             }
             Selection.setSelection(mText, selStart, selEnd);
             geckoPostToIc(new Runnable() {
                 @Override
                 public void run() {
                     mActionQueue.syncWithGecko();
                     final int start = Selection.getSelectionStart(mText);
                     final int end = Selection.getSelectionEnd(mText);
                     if (selStart == start && selEnd == end) {
                         // There has not been another new selection in the mean time that
                         // made this notification out-of-date
                         mListener.onSelectionChange(start, end);
                     }
                 }
             });
             break;
         case Action.TYPE_SET_SPAN:
             mText.setSpan(action.mSpanObject, action.mStart, action.mEnd, action.mSpanFlags);
             break;
         case Action.TYPE_SET_HANDLER:
             geckoSetIcHandler(action.mHandler);
             break;
         }
         if (action.mShouldUpdate) {
             geckoUpdateGecko(false);
         }
     }
     @Override
     public void notifyIME(final int type) {
         if (DEBUG) {
             // GeckoEditableListener methods should all be called from the Gecko thread
             ThreadUtils.assertOnGeckoThread();
             // NOTIFY_IME_REPLY_EVENT is logged separately, inside geckoActionReply()
             if (type != NOTIFY_IME_REPLY_EVENT) {
                 Log.d(LOGTAG, "notifyIME(" +
                               getConstantName(GeckoEditableListener.class, "NOTIFY_IME_", type) +
                               ")");
             }
         }
         if (type == NOTIFY_IME_REPLY_EVENT) {
             try {
                 if (mFocused) {
                     // When mFocused is false, the reply is for a stale action,
                     // and we should not do anything
                     geckoActionReply();
                 } else if (DEBUG) {
                     Log.d(LOGTAG, "discarding stale reply");
                 }
             } finally {
                 // Ensure action is always removed from queue
                 // even if stale action results in exception in geckoActionReply
                 mActionQueue.poll();
             }
             return;
         }
         geckoPostToIc(new Runnable() {
             @Override
             public void run() {
                 if (type == NOTIFY_IME_OF_BLUR) {
                     mFocused = false;
                 } else if (type == NOTIFY_IME_OF_FOCUS) {
                     mFocused = true;
                     // Unmask events on the Gecko side
                     mActionQueue.offer(new Action(Action.TYPE_ACKNOWLEDGE_FOCUS));
                 }
                 // Make sure there are no other things going on. If we sent
                 // GeckoEvent.IME_ACKNOWLEDGE_FOCUS, this line also makes us
                 // wait for Gecko to update us on the newly focused content
                 mActionQueue.syncWithGecko();
                 mListener.notifyIME(type);
             }
         });
         // Register/unregister Gecko-side text selection listeners
         // and update the mGeckoFocused flag.
         if (type == NOTIFY_IME_OF_BLUR && mGeckoFocused) {
             // Check for focus here because Gecko may send us a blur before a focus in some
             // cases, and we don't want to unregister an event that was not registered.
             mGeckoFocused = false;
             mSuppressCompositions = false;
             GeckoAppShell.getEventDispatcher().
                 unregisterEventListener("TextSelection:DraggingHandle", this);
         } else if (type == NOTIFY_IME_OF_FOCUS) {
             mGeckoFocused = true;
             mSuppressCompositions = false;
             GeckoAppShell.getEventDispatcher().
                 registerEventListener("TextSelection:DraggingHandle", this);
         }
     }
     @Override
     public void notifyIMEContext(final int state, final String typeHint,
                           final String modeHint, final String actionHint) {
         // Because we want to be able to bind GeckoEditable to the newest LayerView instance,
         // this can be called from the Java IC thread in addition to the Gecko thread.
         if (DEBUG) {
             Log.d(LOGTAG, "notifyIMEContext(" +
                           getConstantName(GeckoEditableListener.class, "IME_STATE_", state) +
                           ", \"" + typeHint + "\", \"" + modeHint + "\", \"" + actionHint + "\")");
         }
         geckoPostToIc(new Runnable() {
             @Override
             public void run() {
                 // Make sure there are no other things going on
                 mActionQueue.syncWithGecko();
                 // Set InputConnectionHandler in notifyIMEContext because
                 // GeckoInputConnection.notifyIMEContext calls restartInput() which will invoke
                 // InputConnectionHandler.onCreateInputConnection
                 LayerView v = GeckoAppShell.getLayerView();
                 if (v != null) {
                     mListener = GeckoInputConnection.create(v, GeckoEditable.this);
                     v.setInputConnectionHandler((InputConnectionHandler)mListener);
                     mListener.notifyIMEContext(state, typeHint, modeHint, actionHint);
                 }
             }
         });
     }
     @Override
     public void onSelectionChange(final int start, final int end) {
         if (DEBUG) {
             // GeckoEditableListener methods should all be called from the Gecko thread
             ThreadUtils.assertOnGeckoThread();
             Log.d(LOGTAG, "onSelectionChange(" + start + ", " + end + ")");
         }
         if (start < 0 || start > mText.length() || end < 0 || end > mText.length()) {
             throw new IllegalArgumentException("invalid selection notification range: " +
                 start + " to " + end + ", length: " + mText.length());
         }
         final int seqnoWhenPosted = ++mGeckoUpdateSeqno;
         /* An event (keypress, etc.) has potentially changed the selection,
            synchronize the selection here. There is not a race with the IC thread
            because the IC thread should be blocked on the event action */
         if (!mActionQueue.isEmpty() &&
             mActionQueue.peek().mType == Action.TYPE_EVENT) {
             Selection.setSelection(mText, start, end);
             return;
         }
         geckoPostToIc(new Runnable() {
             @Override
             public void run() {
                 mActionQueue.syncWithGecko();
                 /* check to see there has not been another action that potentially changed the
                    selection. If so, we can skip this update because we know there is another
                    update right after this one that will replace the effect of this update */
                 if (mGeckoUpdateSeqno == seqnoWhenPosted) {
                     /* In this case, Gecko's selection has changed and it's notifying us to change
                        Java's selection. In the normal case, whenever Java's selection changes,
                        we go back and set Gecko's selection as well. However, in this case,
                        since Gecko's selection is already up-to-date, we skip this step. */
                     boolean oldUpdateGecko = mUpdateGecko;
                     mUpdateGecko = false;
                     Selection.setSelection(mProxy, start, end);
                     mUpdateGecko = oldUpdateGecko;
                 }
             }
         });
     }
     private void geckoReplaceText(int start, int oldEnd, CharSequence newText) {
         // Don't use replace() because Gingerbread has a bug where if the replaced text
         // has the same spans as the original text, the spans will end up being deleted
         mText.delete(start, oldEnd);
         mText.insert(start, newText);
     }
     @Override
     public void onTextChange(final String text, final int start,
                       final int unboundedOldEnd, final int unboundedNewEnd) {
         if (DEBUG) {
             // GeckoEditableListener methods should all be called from the Gecko thread
             ThreadUtils.assertOnGeckoThread();
             StringBuilder sb = new StringBuilder("onTextChange(");
             debugAppend(sb, text);
             sb.append(", ").append(start).append(", ")
                 .append(unboundedOldEnd).append(", ")
                 .append(unboundedNewEnd).append(")");
             Log.d(LOGTAG, sb.toString());
         }
         if (start < 0 || start > unboundedOldEnd) {
             throw new IllegalArgumentException("invalid text notification range: " +
                 start + " to " + unboundedOldEnd);
         }
         /* For the "end" parameters, Gecko can pass in a large
            number to denote "end of the text". Fix that here */
         final int oldEnd = unboundedOldEnd > mText.length() ? mText.length() : unboundedOldEnd;
         // new end should always match text
         if (start != 0 && unboundedNewEnd != (start + text.length())) {
             throw new IllegalArgumentException("newEnd does not match text: " +
                 unboundedNewEnd + " vs " + (start + text.length()));
         }
         final int newEnd = start + text.length();
         /* Text changes affect the selection as well, and we may not receive another selection
            update as a result of selection notification masking on the Gecko side; therefore,
            in order to prevent previous stale selection notifications from occurring, we need
            to increment the seqno here as well */
         ++mGeckoUpdateSeqno;
         mChangedText.clearSpans();
         mChangedText.replace(0, mChangedText.length(), text);
         // Preserve as many spans as possible
         TextUtils.copySpansFrom(mText, start, Math.min(oldEnd, newEnd),
                                 Object.class, mChangedText, 0);
         if (!mActionQueue.isEmpty()) {
             final Action action = mActionQueue.peek();
             if (action.mType == Action.TYPE_REPLACE_TEXT &&
                     start <= action.mStart &&
                     action.mStart + action.mSequence.length() <= newEnd) {
                 // actionNewEnd is the new end of the original replacement action
                 final int actionNewEnd = action.mStart + action.mSequence.length();
                 int selStart = Selection.getSelectionStart(mText);
                 int selEnd = Selection.getSelectionEnd(mText);
                 // Replace old spans with new spans
                 mChangedText.replace(action.mStart - start, actionNewEnd - start,
                                      action.mSequence);
                 geckoReplaceText(start, oldEnd, mChangedText);
                 // delete/insert above might have moved our selection to somewhere else
                 // this happens when the Gecko text change covers a larger range than
                 // the original replacement action. Fix selection here
                 if (selStart >= start && selStart <= oldEnd) {
                     selStart = selStart < action.mStart ? selStart :
                                selStart < action.mEnd   ? actionNewEnd :
                                                           selStart + actionNewEnd - action.mEnd;
                     mText.setSpan(Selection.SELECTION_START, selStart, selStart,
                                   Spanned.SPAN_POINT_POINT);
                 }
                 if (selEnd >= start && selEnd <= oldEnd) {
                     selEnd = selEnd < action.mStart ? selEnd :
                              selEnd < action.mEnd   ? actionNewEnd :
                                                       selEnd + actionNewEnd - action.mEnd;
                     mText.setSpan(Selection.SELECTION_END, selEnd, selEnd,
                                   Spanned.SPAN_POINT_POINT);
                 }
             } else {
                 geckoReplaceText(start, oldEnd, mChangedText);
             }
         } else {
             geckoReplaceText(start, oldEnd, mChangedText);
         }
         geckoPostToIc(new Runnable() {
             @Override
             public void run() {
                 mListener.onTextChange(text, start, oldEnd, newEnd);
             }
         });
     }
     // InvocationHandler interface
     static String getConstantName(Class<?> cls, String prefix, Object value) {
         for (Field fld : cls.getDeclaredFields()) {
             try {
                 if (fld.getName().startsWith(prefix) &&
                     fld.get(null).equals(value)) {
                     return fld.getName();
                 }
             } catch (IllegalAccessException e) {
             }
         }
         return String.valueOf(value);
     }
     static StringBuilder debugAppend(StringBuilder sb, Object obj) {
         if (obj == null) {
             sb.append("null");
         } else if (obj instanceof GeckoEditable) {
             sb.append("GeckoEditable");
         } else if (Proxy.isProxyClass(obj.getClass())) {
             debugAppend(sb, Proxy.getInvocationHandler(obj));
         } else if (obj instanceof CharSequence) {
             sb.append("\"").append(obj.toString().replace('\n', '\u21b2')).append("\"");
         } else if (obj.getClass().isArray()) {
             sb.append(obj.getClass().getComponentType().getSimpleName()).append("[")
               .append(java.lang.reflect.Array.getLength(obj)).append("]");
         } else {
             sb.append(obj.toString());
         }
         return sb;
     }
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
                          throws Throwable {
         Object target;
         final Class<?> methodInterface = method.getDeclaringClass();
         if (DEBUG) {
             // Editable methods should all be called from the IC thread
             assertOnIcThread();
         }
         if (methodInterface == Editable.class ||
                 methodInterface == Appendable.class ||
                 methodInterface == Spannable.class) {
             // Method alters the Editable; route calls to our implementation
             target = this;
         } else {
             // Method queries the Editable; must sync with Gecko first
             // then call on the inner Editable itself
             mActionQueue.syncWithGecko();
             target = mText;
         }
         Object ret;
         try {
             ret = method.invoke(target, args);
         } catch (InvocationTargetException e) {
             // Bug 817386
             // Most likely Gecko has changed the text while GeckoInputConnection is
             // trying to access the text. If we pass through the exception here, Fennec
             // will crash due to a lack of exception handler. Log the exception and
             // return an empty value instead.
             if (!(e.getCause() instanceof IndexOutOfBoundsException)) {
                 // Only handle IndexOutOfBoundsException for now,
                 // as other exceptions might signal other bugs
                 throw e;
             }
             Log.w(LOGTAG, "Exception in GeckoEditable." + method.getName(), e.getCause());
             Class<?> retClass = method.getReturnType();
             if (retClass == Character.TYPE) {
                 ret = '\0';
             } else if (retClass == Integer.TYPE) {
                 ret = 0;
             } else if (retClass == String.class) {
                 ret = "";
             } else {
                 ret = null;
             }
         }
         if (DEBUG) {
             StringBuilder log = new StringBuilder(method.getName());
             log.append("(");
             for (Object arg : args) {
                 debugAppend(log, arg).append(", ");
             }
             if (args.length > 0) {
                 log.setLength(log.length() - 2);
             }
             if (method.getReturnType().equals(Void.TYPE)) {
                 log.append(")");
             } else {
                 debugAppend(log.append(") = "), ret);
             }
             Log.d(LOGTAG, log.toString());
         }
         return ret;
     }
     // Spannable interface
     @Override
     public void removeSpan(Object what) {
         if (what == Selection.SELECTION_START ||
                 what == Selection.SELECTION_END) {
             Log.w(LOGTAG, "selection removed with removeSpan()");
         }
         if (mText.getSpanStart(what) >= 0) { // only remove if it's there
             // Okay to remove immediately
             mText.removeSpan(what);
             mActionQueue.offer(new Action(Action.TYPE_REMOVE_SPAN));
         }
     }
     @Override
     public void setSpan(Object what, int start, int end, int flags) {
         if (what == Selection.SELECTION_START) {
             if ((flags & Spanned.SPAN_INTERMEDIATE) != 0) {
                 // We will get the end offset next, just save the start for now
                 mSavedSelectionStart = start;
             } else {
                 mActionQueue.offer(Action.newSetSelection(start, -1));
             }
         } else if (what == Selection.SELECTION_END) {
             mActionQueue.offer(Action.newSetSelection(mSavedSelectionStart, end));
             mSavedSelectionStart = -1;
         } else {
             mActionQueue.offer(Action.newSetSpan(what, start, end, flags));
         }
     }
     // Appendable interface
     @Override
     public Editable append(CharSequence text) {
         return replace(mProxy.length(), mProxy.length(), text, 0, text.length());
     }
     @Override
     public Editable append(CharSequence text, int start, int end) {
         return replace(mProxy.length(), mProxy.length(), text, start, end);
     }
     @Override
     public Editable append(char text) {
         return replace(mProxy.length(), mProxy.length(), String.valueOf(text), 0, 1);
     }
     // Editable interface
     @Override
     public InputFilter[] getFilters() {
         return mFilters;
     }
     @Override
     public void setFilters(InputFilter[] filters) {
         mFilters = filters;
     }
     @Override
     public void clearSpans() {
         /* XXX this clears the selection spans too,
            but there is no way to clear the corresponding selection in Gecko */
         Log.w(LOGTAG, "selection cleared with clearSpans()");
         mText.clearSpans();
     }
     @Override
     public Editable replace(int st, int en,
             CharSequence source, int start, int end) {
         CharSequence text = source;
         if (start < 0 || start > end || end > text.length()) {
             throw new IllegalArgumentException("invalid replace offsets: " +
                 start + " to " + end + ", length: " + text.length());
         }
         if (start != 0 || end != text.length()) {
             text = text.subSequence(start, end);
         }
         if (mFilters != null) {
             // Filter text before sending the request to Gecko
             for (int i = 0; i < mFilters.length; ++i) {
                 final CharSequence cs = mFilters[i].filter(
                         text, 0, text.length(), mProxy, st, en);
                 if (cs != null) {
                     text = cs;
                 }
             }
         }
         if (text == source) {
             // Always create a copy
             text = new SpannableString(source);
         }
         mActionQueue.offer(Action.newReplaceText(text,
                 Math.min(st, en), Math.max(st, en)));
         return mProxy;
     }
     @Override
     public void clear() {
         replace(0, mProxy.length(), "", 0, 0);
     }
     @Override
     public Editable delete(int st, int en) {
         return replace(st, en, "", 0, 0);
     }
     @Override
     public Editable insert(int where, CharSequence text,
                                 int start, int end) {
         return replace(where, where, text, start, end);
     }
     @Override
     public Editable insert(int where, CharSequence text) {
         return replace(where, where, text, 0, text.length());
     }
     @Override
     public Editable replace(int st, int en, CharSequence text) {
         return replace(st, en, text, 0, text.length());
     }
     /* GetChars interface */
     @Override
     public void getChars(int start, int end, char[] dest, int destoff) {
         /* overridden Editable interface methods in GeckoEditable must not be called directly
            outside of GeckoEditable. Instead, the call must go through mProxy, which ensures
            that Java is properly synchronized with Gecko */
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     /* Spanned interface */
     @Override
     public int getSpanEnd(Object tag) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public int getSpanFlags(Object tag) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public int getSpanStart(Object tag) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public <T> T[] getSpans(int start, int end, Class<T> type) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     @SuppressWarnings("rawtypes") // nextSpanTransition uses raw Class in its Android declaration
     public int nextSpanTransition(int start, int limit, Class type) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     /* CharSequence interface */
     @Override
     public char charAt(int index) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public int length() {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public CharSequence subSequence(int start, int end) {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     @Override
     public String toString() {
         throw new UnsupportedOperationException("method must be called through mProxy");
     }
     // GeckoEventListener implementation
     @Override
     public void handleMessage(String event, JSONObject message) {
         if (!"TextSelection:DraggingHandle".equals(event)) {
             return;
         }
         mSuppressCompositions = message.optBoolean("dragging", false);
     }
 }

The Tor Browser / annotate

mobile/android/base/GeckoEditable.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoEditable.java