Implement Virtual Display class for Android.

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

Index: ui/android/java/src/org/chromium/ui/display/VirtualDisplayAndroid.java
diff --git a/ui/android/java/src/org/chromium/ui/display/VirtualDisplayAndroid.java b/ui/android/java/src/org/chromium/ui/display/VirtualDisplayAndroid.java
new file mode 100644
index 0000000000000000000000000000000000000000..448d283d2a7bcc6b94f8e14b5fa37eb5dbe637b0
--- /dev/null
+++ b/ui/android/java/src/org/chromium/ui/display/VirtualDisplayAndroid.java
@@ -0,0 +1,121 @@
+// 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.graphics.Point;
+
+/**
+ * An instance of DisplayAndroid not associated with any physical display.
+ */
+public class VirtualDisplayAndroid extends DisplayAndroid {

[amp, 2016/11/23 19:18:09]

Would it be possible to add an 'isVirtual' field to the display so that code
that makes assumptions about physical displays (such as the media player
creating a surface to output directly to the physical display) could take these
new types of displays into account?

[mthiesse, 2016/11/23 19:22:23]

Preferably, virtual vs. physical displays would be transparent to the rest of
the code base. Where does the code live that does this? How is it currently
accessing the Display?

[amp, 2016/11/23 19:34:34]

I agree that ideally no code would need to know the difference.

https://codereview.chromium.org/2439543003/ is my change where I attempt to add
a inVR flag (on top of one of your previous patches).  It's essentially the same
property of if a display is virtual or not.

The webmediaplayer_impl doesn't interact with the display directly, but through
some interaction with the surface manager (which I don't really understand):
https://cs.chromium.org/chromium/src/media/blink/webmediaplayer_impl.cc?sq=pa...

If it can be aware that it isn't running on an actual physical display then we
can disable the overlay and everything works even in vr mode.

[mthiesse, 2016/11/23 19:44:51]

I really don't think we should convey VR-ness or whether or not to use overlays
based on a display property. If the media player needs to know if we're in VR,
than it needs some other channel through which to pass that information.

[amp, 2016/11/23 20:09:22]

I'm interested in other solutions if possible.  Anyway I think it's contentious
enough that you don't need to worry about it in this change.  I'll bring up the
discussion again when my change goes out for review.

+    private final int mDisplayId;
+    private Point mSize;
+    private Point mPhysicalSize;
+    private float mDipScale;
+    private int mBitsPerPixel;
+    private int mBitsPerComponent;
+    private int mRotation;
+
+    /**
+     * @param displayId Display ID for this virtual display.
+     */
+    public static VirtualDisplayAndroid createVirtualDisplay(int displayId) {
+        VirtualDisplayAndroid display = new VirtualDisplayAndroid(displayId);
+        getManager().addVirtualDisplay(display);
+        return display;
+    }
+
+    private VirtualDisplayAndroid(int displayId) {
+        mDisplayId = displayId;
+    }
+
+    /**
+     * @param other Sets the properties of this display to those of the other display.
+     */
+    public void setTo(DisplayAndroid other) {
+        update(new Point(other.getDisplayWidth(), other.getDisplayHeight()),
+                new Point(other.getPhysicalDisplayWidth(), other.getPhysicalDisplayHeight()),
+                other.getDipScale(), other.getBitsPerPixel(),
+                other.getBitsPerComponent(), other.getRotation());
+    }
+
+    /**
+     * Update the display to the provided parameters. Null values leave the parameter unchanged.
+     */
+    public void update(Point size, Point physicalSize, Float dipScale, Integer bitsPerPixel,
+            Integer bitsPerComponent, Integer rotation) {
+        boolean dipScaleChanged = dipScale != null && mDipScale != dipScale;
+        boolean rotationChanged = rotation != null && mRotation != rotation;
+        mSize = size == null ? mSize : size;
+        mPhysicalSize = size == null ? mPhysicalSize : physicalSize;
+        mDipScale = size == null ? mDipScale : dipScale;
+        mBitsPerPixel = size == null ? mBitsPerPixel : bitsPerPixel;
+        mBitsPerComponent = size == null ? mBitsPerComponent : bitsPerComponent;
+        mRotation = size == null ? mRotation : rotation;
+        getManager().updateDisplayOnNativeSide(this);
+        notifyObservers(dipScaleChanged, rotationChanged);
+    }
+
+    private void notifyObservers(boolean dipScaleChanged, boolean rotationChanged) {
+        if (!dipScaleChanged && !rotationChanged) return;
+        DisplayAndroidObserver[] observers = getObservers();
+        for (DisplayAndroidObserver o : observers) {
+            if (dipScaleChanged) o.onDIPScaleChanged(mDipScale);
+            if (rotationChanged) o.onRotationChanged(mRotation);
+        }
+    }
+
+    @Override
+    public int getSdkDisplayId() {
+        return mDisplayId;
+    }
+
+    @Override
+    public int getDisplayHeight() {
+        return mSize.y;
+    }
+
+    @Override
+    public int getDisplayWidth() {
+        return mSize.x;
+    }
+
+    @Override
+    public int getPhysicalDisplayHeight() {
+        return mPhysicalSize.y;
+    }
+
+    @Override
+    public int getPhysicalDisplayWidth() {
+        return mPhysicalSize.x;
+    }
+
+    @Override
+    public int getRotation() {
+        return mRotation;
+    }
+
+    @Override
+    public float getDipScale() {
+        return mDipScale;
+    }
+
+    @Override
+    /* package */ int getBitsPerPixel() {
+        return mBitsPerPixel;
+    }
+
+    @Override
+    /* package */ int getBitsPerComponent() {
+        return mBitsPerComponent;
+    }
+
+    /**
+     * Removes this Virtual Display from the DisplayManger.
+     */
+    public void destroy() {
+        getManager().removeVirtualDisplay(this);
+    }
+}