[Android] Allow text handles to observe position of "parent" view

base/android/java/src/org/chromium/base/PositionObserver.java

Index: base/android/java/src/org/chromium/base/PositionObserver.java
diff --git a/base/android/java/src/org/chromium/base/PositionObserver.java b/base/android/java/src/org/chromium/base/PositionObserver.java
new file mode 100644
index 0000000000000000000000000000000000000000..9efe2c49206d82a08961ba1675e54d15c7f6a3f9
--- /dev/null
+++ b/base/android/java/src/org/chromium/base/PositionObserver.java
@@ -0,0 +1,111 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[joth, 2013/09/27 22:23:20]

this yr

[cjhopman, 2013/10/04 18:07:29]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.base;

[joth, 2013/09/27 22:23:20]

This is only needed in content/browser so I don't think it meets the bar for
needing to go in base. (ui/ maybe, if there were other users for it)

[cjhopman, 2013/10/04 18:07:29]

Done.

+
+import android.view.View;
+import android.view.ViewTreeObserver;
+
+import java.util.ArrayList;
+
+/**
+ * Used to register listeners that can be notified of changes to the position of a view.
+ */
+public class PositionObserver {
+    public interface Listener {
+        /**
+         * Called during predraw if the position of the underlying view has changed.
+         */
+        public void onPositionChanged(int positionX, int positionY);
+    }
+
+    private View mView;
+    // Absolute position of the container view relative to its parent window.
+    private int mPositionX, mPositionY;
+
+    private ArrayList<Listener> mListeners;
+    private ViewTreeObserver.OnPreDrawListener mPreDrawListener;
+
+    /**
+     * @param view The view to observe.
+     */
+    public PositionObserver(View view) {
+        mView = view;
+        mListeners = new ArrayList<Listener>();
+        updatePosition();
+        mPreDrawListener = new ViewTreeObserver.OnPreDrawListener() {
+            @Override
+            public boolean onPreDraw() {
+                if (updatePosition()) {
+                    for (Listener l : mListeners) {
+                        l.onPositionChanged(mPositionX, mPositionY);
+                    }
+                }
+                return true;
+            }
+        };
+    }
+
+    /**
+     * @return The current x position of the observed view.
+     */
+    public int getPositionX() {
+        // The stored position may be out-of-date. Get the real current position.

[joth, 2013/09/27 22:23:20]

the position will be correct during a frame draw, and will always correspond to
the most recent frame between frames.
Is that not good enough?

[cjhopman, 2013/10/04 18:07:29]

The preDrawListener is only registered on the view tree if there is a listener
on this observer. So, the stored position can become stale while nobody is
listening for changes.

This comes up when showing the text handles. They check if the selection point
is actually visible on-screen before being shown and so they need to get the
current position.

+        return getCurrentPosition()[0];
+    }
+
+    /**
+     * @return The current y position of the observed view.
+     */
+    public int getPositionY() {
+        // The stored position may be out-of-date. Get the real current position.
+        return getCurrentPosition()[1];
+    }
+
+    /**
+     * Register a listener to be called when the position of the underlying view changes.
+     */
+    public void addListener(Listener listener) {
+        if (mListeners.contains(listener)) {
+            return;
+        }
+
+        if (mListeners.isEmpty()) {
+            mView.getViewTreeObserver().addOnPreDrawListener(mPreDrawListener);
+            updatePosition();
+        }
+
+        mListeners.add(listener);
+    }
+
+    /**
+     * Remove a previously installed listener.
+     */
+    public void removeListener(Listener listener) {
+        if (!mListeners.contains(listener)) {
+            return;
+        }
+
+        mListeners.remove(listener);
+
+        if (mListeners.isEmpty()) {
+            mView.getViewTreeObserver().removeOnPreDrawListener(mPreDrawListener);
+        }
+    }
+
+    private int[] getCurrentPosition() {
+        int[] position = new int[2];

[joth, 2013/09/27 22:23:20]

this will cause garbage allocations on every frame drawn. I think you can use a
long lived int[2] and pass into getLocationInWindow() to avoid this

[cjhopman, 2013/10/04 18:07:29]

Done.

+        mView.getLocationInWindow(position);
+        return position;
+    }
+
+    private boolean updatePosition() {
+        int[] position = getCurrentPosition();
+        boolean positionChanged = mPositionX != position[0] || mPositionY != position[1];
+        mPositionX = position[0];
+        mPositionY = position[1];
+        return positionChanged;
+    }
+}
+