The Tor Browser: mobile/android/base/tests/components/GeckoViewComponent.java@fc2d59ddac77 (annotated)

mobile/android/base/tests/components/GeckoViewComponent.java@fc2d59ddac77 (annotated)

mobile/android/base/tests/components/GeckoViewComponent.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.

 /* 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.tests.components;
 import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertNotNull;
 import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertNotSame;
 import static org.mozilla.gecko.tests.helpers.AssertionHelper.fAssertTrue;
 import org.mozilla.gecko.R;
 import org.mozilla.gecko.tests.UITestContext;
 import org.mozilla.gecko.tests.helpers.FrameworkHelper;
 import org.mozilla.gecko.tests.helpers.WaitHelper;
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.os.Handler;
 import android.os.Looper;
 import android.view.View;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
 import android.view.inputmethod.InputMethodManager;
 import com.jayway.android.robotium.solo.Condition;
 /**
  * A class representing any interactions that take place on GeckoView.
  */
 public class GeckoViewComponent extends BaseComponent {
     public interface InputConnectionTest {
         public void test(InputConnection ic, EditorInfo info);
     }
     public final TextInput mTextInput;
     public GeckoViewComponent(final UITestContext testContext) {
         super(testContext);
         mTextInput = new TextInput();
     }
     /**
      * Returns the GeckoView.
      */
     private View getView() {
         // Solo.getView asserts returning a valid View
         return mSolo.getView(R.id.layer_view);
     }
     private void setContext(final Context newContext) {
         final View geckoView = getView();
         // Switch to a no-InputMethodManager context to avoid interference
         mTestContext.getInstrumentation().runOnMainSync(new Runnable() {
             @Override
             public void run() {
                 FrameworkHelper.setViewContext(geckoView, newContext);
             }
         });
     }
     public class TextInput {
         private TextInput() {
         }
         private InputMethodManager getInputMethodManager() {
             final InputMethodManager imm = (InputMethodManager)
                 mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
             fAssertNotNull("Must have an InputMethodManager", imm);
             return imm;
         }
         /**
          * Returns whether text input is being directed to the GeckoView.
          */
         private boolean isActive() {
             return getInputMethodManager().isActive(getView());
         }
         public TextInput assertActive() {
             fAssertTrue("Current view should be the active input view", isActive());
             return this;
         }
         public TextInput waitForActive() {
             WaitHelper.waitFor("current view to become the active input view", new Condition() {
                 @Override
                 public boolean isSatisfied() {
                     return isActive();
                 }
             });
             return this;
         }
         /**
          * Returns whether an InputConnection is avaiable.
          * An InputConnection is available when text input is being directed to the
          * GeckoView, and a text field (input, textarea, contentEditable, etc.) is
          * currently focused inside the GeckoView.
          */
         private boolean hasInputConnection() {
             final InputMethodManager imm = getInputMethodManager();
             return imm.isActive(getView()) && imm.isAcceptingText();
         }
         public TextInput assertInputConnection() {
             fAssertTrue("Current view should have an active InputConnection", hasInputConnection());
             return this;
         }
         public TextInput waitForInputConnection() {
             WaitHelper.waitFor("current view to have an active InputConnection", new Condition() {
                 @Override
                 public boolean isSatisfied() {
                     return hasInputConnection();
                 }
             });
             return this;
         }
         /**
          * Starts an InputConnectionTest. An InputConnectionTest must run on the
          * InputConnection thread which may or may not be the main UI thread. Also,
          * during an InputConnectionTest, the system InputMethodManager service must
          * be temporarily disabled to prevent the system IME from interfering with our
          * tests. We disable the service by override the GeckoView's context with one
          * that returns a null InputMethodManager service.
          *
          * @param test Test to run
          */
         public TextInput testInputConnection(final InputConnectionTest test) {
             fAssertNotNull("Test must not be null", test);
             assertInputConnection();
             // GeckoInputConnection can run on another thread than the main thread,
             // so we need to be testing it on that same thread it's running on
             final View geckoView = getView();
             final Handler inputConnectionHandler = geckoView.getHandler();
             final Context oldGeckoViewContext = FrameworkHelper.getViewContext(geckoView);
             setContext(new ContextWrapper(oldGeckoViewContext) {
                 @Override
                 public Object getSystemService(String name) {
                     if (Context.INPUT_METHOD_SERVICE.equals(name)) {
                         return null;
                     }
                     return super.getSystemService(name);
                 }
             });
             (new InputConnectionTestRunner(test)).runOnHandler(inputConnectionHandler);
             setContext(oldGeckoViewContext);
             return this;
         }
         private class InputConnectionTestRunner implements Runnable {
             private final InputConnectionTest mTest;
             private boolean mDone;
             public InputConnectionTestRunner(final InputConnectionTest test) {
                 mTest = test;
             }
             public synchronized void runOnHandler(final Handler inputConnectionHandler) {
                 // Below, we are blocking the instrumentation thread to wait on the
                 // InputConnection thread. Therefore, the InputConnection thread must not be
                 // the same as the instrumentation thread to avoid a deadlock. This should
                 // always be the case and we perform a sanity check to make sure.
                 fAssertNotSame("InputConnection should not be running on instrumentation thread",
                     Looper.myLooper(), inputConnectionHandler.getLooper());
                 mDone = false;
                 inputConnectionHandler.post(this);
                 do {
                     try {
                         wait();
                     } catch (InterruptedException e) {
                         // Ignore interrupts
                     }
                 } while (!mDone);
             }
             @Override
             public void run() {
                 final EditorInfo info = new EditorInfo();
                 final InputConnection ic = getView().onCreateInputConnection(info);
                 fAssertNotNull("Must have an InputConnection", ic);
                 // Restore the IC to a clean state
                 ic.clearMetaKeyStates(-1);
                 ic.finishComposingText();
                 mTest.test(ic, info);
                 synchronized (this) {
                     // Test finished; return from runOnHandler
                     mDone = true;
                     notify();
                 }
             }
         }
     }
 }

The Tor Browser / annotate

mobile/android/base/tests/components/GeckoViewComponent.java@fc2d59ddac77 (annotated)

mobile/android/base/tests/components/GeckoViewComponent.java