Reland of Android: support multiple displays on C++ side

ui/android/java/src/org/chromium/ui/display/DisplayAndroidManager.java

 // Copyright 2016 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.ui.display;
 
 import android.annotation.SuppressLint;
 import android.content.ComponentCallbacks;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.os.Build;
 import android.util.SparseArray;
 import android.view.Display;
 import android.view.WindowManager;
 
 import org.chromium.base.ContextUtils;
 import org.chromium.base.ThreadUtils;
+import org.chromium.base.annotations.JNINamespace;
 import org.chromium.ui.gfx.DeviceDisplayInfo;
 
 /**
  * DisplayAndroidManager is a class that informs its observers Display changes.
  */
+@JNINamespace("display")
 /* package */ class DisplayAndroidManager {
     /**
      * DisplayListenerBackend is an interface that abstract the mechanism used for the actual
      * display update listening. The reason being that from Android API Level 17 DisplayListener
      * will be used. Before that, an unreliable solution based on onConfigurationChanged has to be
      * used.
      */
     private interface DisplayListenerBackend {
 
         /**
@@ skipping 116 matching lines @@
         // DisplayListener implementation:
 
         @Override
         public void onDisplayAdded(int sdkDisplayId) {
             // DisplayAndroid is added lazily on first use. This is to workaround corner case
             // bug where DisplayManager.getDisplay(sdkDisplayId) returning null here.
         }
 
         @Override
         public void onDisplayRemoved(int sdkDisplayId) {
+            // Never remove the primary display.
+            if (sdkDisplayId == Display.DEFAULT_DISPLAY) return;
+
+            DisplayAndroid displayAndroid = mIdMap.get(sdkDisplayId);
+            if (displayAndroid == null) return;
+
+            nativeRemoveDisplay(sdkDisplayId);
             mIdMap.remove(sdkDisplayId);
         }
 
         @Override
         public void onDisplayChanged(int sdkDisplayId) {
             updateDeviceDisplayInfo();
             DisplayAndroid displayAndroid = mIdMap.get(sdkDisplayId);
             if (displayAndroid != null) {
                 displayAndroid.updateFromDisplay(getDisplayManager().getDisplay(sdkDisplayId));
             }
@@ skipping 31 matching lines @@
     }
 
     private static void updateDeviceDisplayInfo() {
         DeviceDisplayInfo.create(getContext()).updateNativeSharedDisplayInfo();
     }
 
     private DisplayAndroidManager() {
         mIdMap = new SparseArray<>();
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
             mBackend = new DisplayListenerBackendImpl();
+            // Make sure the display map contains the built-in primary display if it exists.
+            // The primary display is never removed.
+            Display display = getDisplayManager().getDisplay(Display.DEFAULT_DISPLAY);
+            if (display != null) {
+                addDisplay(display);
+            } else {
+                nativeSetNoPrimaryDisplay();

[mthiesse, 2016/10/27 14:30:30]

This feels scary - should we not just use getDisplayFromContext(getContext()) in
this case and use that as though it's the default display?

Then in onDisplayRemoved you could reject removing the last display from the
list as well, so we always have a display?

[Tima Vaisburd, 2016/10/27 17:56:23]

Sorry, I did not quite get your idea. Do you suggest that if there is no primary
display (with id 0), but some other display exists, we should consider it
primary?
I kept primary here according to the Android documentation: the one with display
id equal to 0.

[mthiesse, 2016/10/27 19:51:51]

Yes, that's what I'm suggesting. I'm not sure what we should do if there's no
display at all. Is that even possible?

[Tima Vaisburd, 2016/10/27 20:22:30]

I do not know, maybe not possible.
Another idea is to come up with default properties (size, density etc.), or have
the values corresponding to Display() with 32 bits per pixel (Android now has
only RGBA_8888 pixel format). Actually the latter seems reasonable to me, what
do you think?

[mthiesse, 2016/10/27 20:29:13]

I'll have to defer to Bo here, I don't know enough in this space.

[boliu, 2016/10/27 22:17:49]

I don't this that can ever happen. throw an exception and hope for the best,
since this is android..?

or if you want to be safer, get the default display from the application
context, that should always be the default display, I hope..

[Tima Vaisburd, 2016/10/31 23:36:15]

Got Display from the application context. I had to pass the display ID to the
native side since I wasn't sure that the Display in this case will always have
is equal to 0.

+            }
         } else {
             Display display = getDisplayFromContext(getContext());
             mBackend = new DisplayListenerAPI16(display.getDisplayId());
             addDisplay(display);  // Note this display is never removed.
         }
         mBackend.startListening();
     }
 
     /* package */ DisplayAndroid getDisplayAndroid(Display display) {
         int sdkDisplayId = display.getDisplayId();
         DisplayAndroid displayAndroid = mIdMap.get(sdkDisplayId);
         if (displayAndroid == null) {
             displayAndroid = addDisplay(display);
         }
         return displayAndroid;
     }
 
     /* package */ void startAccurateListening() {
         mBackend.startAccurateListening();
     }
 
     /* package */ void stopAccurateListening() {
         mBackend.stopAccurateListening();
     }
 
     private DisplayAndroid addDisplay(Display display) {
         int sdkDisplayId = display.getDisplayId();
         DisplayAndroid displayAndroid = new DisplayAndroid(display);
         mIdMap.put(sdkDisplayId, displayAndroid);
+
+        updateDisplayOnNativeSide(displayAndroid);
         return displayAndroid;
     }
+
+    /* package */ void updateDisplayOnNativeSide(DisplayAndroid displayAndroid) {
+        nativeUpdateDisplay(displayAndroid.getSdkDisplayId(),
+                displayAndroid.getPhysicalDisplayWidth(), displayAndroid.getPhysicalDisplayHeight(),
+                displayAndroid.getDisplayWidth(), displayAndroid.getDisplayHeight(),
+                displayAndroid.getDIPScale(), displayAndroid.getRotationDegrees(),
+                displayAndroid.getBitsPerPixel(), displayAndroid.getBitsPerComponent());
+    }
+
+    private static native void nativeUpdateDisplay(int sdkDisplayId, int physicalWidth,
+            int physicalHeight, int width, int height, float dipScale, int rotationDegrees,
+            int bitsPerPixel, int bitsPerComponent);
+    private static native void nativeRemoveDisplay(int sdkDisplayId);
+    private static native void nativeSetNoPrimaryDisplay();
 }