DialogSurfaceManager implementation.

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

 // Copyright 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.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.assist.AssistStructure.ViewNode;
 import android.content.ClipData;
@@ skipping 80 matching lines @@
 @JNINamespace("content")
 public class ContentViewCore implements AccessibilityStateChangeListener, DisplayAndroidObserver,
                                         SystemCaptioningBridge.SystemCaptioningBridgeListener,
                                         WindowAndroidProvider {
     private static final String TAG = "cr_ContentViewCore";
 
     // Used to avoid enabling zooming in / out if resulting zooming will
     // produce little visible difference.
     private static final float ZOOM_CONTROLS_EPSILON = 0.007f;
 
+    /**
+     * Observer for changes to WindowAndroid.  Mirrors
+     * ContentViewCoreImplObserver in native.  Appends 'Android' to (a) match
+     * WindowAndroid, and (b) avoid a name collision with View.
+     */
+    public interface Observer {
+        public void onContentViewCoreDestroyed(ContentViewCore cvc);
+        public void onAttachedToWindowAndroid(ContentViewCore cvc);
+        public void onDetachedFromWindowAndroid(ContentViewCore cvc);
+    }
+
+    // Single observer.  We only support one right now, since we have only one
+    // consumer of it.
+    private Observer mObserver;
+
     // If the embedder adds a JavaScript interface object that contains an indirect reference to
     // the ContentViewCore, then storing a strong ref to the interface object on the native
     // side would prevent garbage collection of the ContentViewCore (as that strong ref would
     // create a new GC root).
     // For that reason, we store only a weak reference to the interface object on the
     // native side. However we still need a strong reference on the Java side to
     // prevent garbage collection if the embedder doesn't maintain their own ref to the
     // interface object - the Java side ref won't create a new GC root.
     // This map stores those references. We put into the map on addJavaScriptInterface()
     // and remove from it in removeJavaScriptInterface(). The annotation class is stored for
@@ skipping 586 matching lines @@
             }
         } finally {
             TraceEvent.end("ContentViewCore.setContainerView");
         }
     }
 
     @CalledByNative
     private void onNativeContentViewCoreDestroyed(long nativeContentViewCore) {
         assert nativeContentViewCore == mNativeContentViewCore;
         mNativeContentViewCore = 0;
+        if (mObserver != null) mObserver.onContentViewCoreDestroyed(this);
     }
 
     /**
      * Set the Container view Internals.
      * @param internalDispatcher Handles dispatching all hidden or super methods to the
      *                           containerView.
      */
     public void setContainerViewInternals(InternalAccessDelegate internalDispatcher) {
         mContainerViewInternals = internalDispatcher;
     }
@@ skipping 2089 matching lines @@
 
     @VisibleForTesting
     public ResultReceiver getNewShowKeyboardReceiver() {
         if (mShowKeyboardResultReceiver == null) {
             // Note: the returned object will get leaked by Android framework.
             mShowKeyboardResultReceiver = new ShowKeyboardResultReceiver(this, new Handler());
         }
         return mShowKeyboardResultReceiver;
     }
 
+    // Set our observer.  We support only a single observer right now.  If
+    // |observer| is already an observer, then do nothing.
+    public void addObserver(Observer observer) {
+        assert mObserver == null || mObserver == observer;
+        mObserver = observer;
+    }
+
+    // Remove our single observer.
+    public void removeObserver(Observer observer) {
+        assert mObserver == observer;
+        // Note that this can be called as part of a callback, so be careful if
+        // we're iterating over a list of observers when this is called.
+        mObserver = null;
+    }
+
+    @CalledByNative
+    private void onAttachedToWindowAndroid() {
+        if (mObserver != null) mObserver.onAttachedToWindowAndroid(this);

[boliu, 2017/01/04 23:14:39]

sigh.. I should really unify these two different "attachToWindow" code paths,
there is no reason they are different

also, taking a step back, we are trying to get rid of ContentViewCore, so adding
more things here is not ideal. the attach/detach event observer probably should
live on ViewAndroid (which only exists in c++ code, though there is no reason it
can't have java observers..)

[liberato (no reviews please), 2017/01/11 22:17:56]

i didn't see an obvious way to do this.  i'll re-check, and probably chat
offline to see how to proceed.

+    }
+
+    @CalledByNative
+    private void onDetachedFromWindowAndroid() {
+        if (mObserver != null) mObserver.onDetachedFromWindowAndroid(this);
+    }
+
     private native long nativeInit(WebContents webContents, ViewAndroidDelegate viewAndroidDelegate,
             long windowAndroidPtr, float dipScale, HashSet<Object> retainedObjectSet);
     private static native ContentViewCore nativeFromWebContentsAndroid(WebContents webContents);
 
     private native void nativeUpdateWindowAndroid(
             long nativeContentViewCoreImpl, long windowAndroidPtr);
     private native WebContents nativeGetWebContentsAndroid(long nativeContentViewCoreImpl);
     private native WindowAndroid nativeGetJavaWindowAndroid(long nativeContentViewCoreImpl);
 
     private native void nativeOnJavaContentViewCoreDestroyed(long nativeContentViewCoreImpl);
@@ skipping 97 matching lines @@
             String textTrackTextShadow, String textTrackTextSize);
 
     private native void nativeExtractSmartClipData(long nativeContentViewCoreImpl,
             int x, int y, int w, int h);
 
     private native void nativeSetBackgroundOpaque(long nativeContentViewCoreImpl, boolean opaque);
     private native boolean nativeIsTouchDragDropEnabled(long nativeContentViewCoreImpl);
     private native void nativeOnDragEvent(long nativeContentViewCoreImpl, int action, int x, int y,
             int screenX, int screenY, String[] mimeTypes, String content);
 }