Add DeviceDisplayInfo getter in WindowAndroid.

ui/android/screen_android.cc

Index: ui/android/screen_android.cc
diff --git a/ui/android/screen_android.cc b/ui/android/screen_android.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6c92cf55e5468296de97b4e2be79641433965f2a
--- /dev/null
+++ b/ui/android/screen_android.cc
@@ -0,0 +1,101 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[sky, 2016/02/24 19:19:08]

no (c) and update year.

[gsennton, 2016/02/25 17:08:04]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "ui/android/screen_android.h"
+#include "ui/android/view_android.h"
+#include "ui/android/window_android.h"
+#include "ui/gfx/android/device_display_info.h"
+#include "ui/gfx/display.h"
+
+namespace ui {
+
+namespace {
+
+gfx::Display DisplayFromDeviceDisplayInfo(

[sky, 2016/02/24 19:18:48]

If ScreenAndroid only ever returns a single display, how could this return
something else?

[boliu, 2016/02/25 05:33:36]

Screen implementation would now needs to listen to events for when extra
displays are added and removed. I hope android provides these events?

That can come from a follow up CL though, like the missing bits in
WindowAndroid.

[gsennton, 2016/02/25 17:08:04]

Yeah, so at the moment we only support one display, but the purpose of this CL
is to provide an API/framework to use when we support other displays - the idea
is that if you provide a NativeView = ViewAndroid which holds a WindowAndroid
(i.e. when you call GetDisplayNearestWindow). That View/WindowAndroid can target
an external display (through the Context held by WindowAndroid). Also,
GetPrimaryDisplay could still target the primary display by just statically
fetching display metrics through the application Context.

I created this standalone CL to add this API (and to change several files to use
the API) because the initial CL adding both this API and the implementation for
fetching display metrics from the correct display was huge and gross and
practically impossible to review//change/move forward :/
Would it really? If each WindowAndroid takes care of fetching its own display we
wouldn't need to keep track of all displays? (though, I'm not yet sure whether
we want to fetch display metrics specifically for each WindowAndroid or just try
to keep some global list of displays and query that from WindowAndroid instead,
so we might want to keep track of the available displays even if we end up not
strictly needing to).
Anyway, in case we do want to keep track of each display, the following is
copy-pasted from the Android documentation:

/**
 * Listens for changes in available display devices.
 */
public interface DisplayListener {
    /**
     * Called whenever a logical display has been added to the system.
     * Use {@link DisplayManager#getDisplay} to get more information about
     * the display.
     *
     * @param displayId The id of the logical display that was added.
     */
    void onDisplayAdded(int displayId);

    /**
     * Called whenever a logical display has been removed from the system.
     *
     * @param displayId The id of the logical display that was removed.
     */
    void onDisplayRemoved(int displayId);

    /**
     * Called whenever the properties of a logical display have changed.
     *
     * @param displayId The id of the logical display that changed.
     */
    void onDisplayChanged(int displayId);
}

[boliu, 2016/02/25 18:11:34]

Current implementation of ScreenAndroid is just wrong if there are multiple
displays:
GetNumDisplays should not just return 1
GetAllDisplays should return more than 1 display
GetDisplayNearestPoint doesn't really make sense on android
etc etc

Either you have to say these methods are not supported on Android and they must
be never called (enforced by NOTIMPLEMENTED or NOTREACHED), or they have to be
implemented correctly.

I don't know which makes more sense.

+    const gfx::DeviceDisplayInfo& device_info) {
+  const float device_scale_factor = device_info.GetDIPScale();
+  // Note: GetPhysicalDisplayWidth/Height() does not subtract window
+  // decorations etc. Use it instead of GetDisplayWidth/Height() when
+  // available.
+  const gfx::Rect bounds_in_pixels =
+      gfx::Rect(device_info.GetPhysicalDisplayWidth()
+                    ? device_info.GetPhysicalDisplayWidth()
+                    : device_info.GetDisplayWidth(),
+                device_info.GetPhysicalDisplayHeight()
+                    ? device_info.GetPhysicalDisplayHeight()
+                    : device_info.GetDisplayHeight());
+  const gfx::Rect bounds_in_dip = gfx::Rect(gfx::ScaleToCeiledSize(
+      bounds_in_pixels.size(), 1.0f / device_scale_factor));
+  gfx::Display display(0, bounds_in_dip);
+  if (!gfx::Display::HasForceDeviceScaleFactor())
+    display.set_device_scale_factor(device_scale_factor);
+  display.SetRotationAsDegree(device_info.GetRotationDegrees());
+  return display;
+}
+
+}  // namespace
+
+class ScreenAndroid : public gfx::Screen {
+ public:
+  ScreenAndroid() {}
+
+  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
+
+  gfx::NativeWindow GetWindowUnderCursor() override {
+    NOTIMPLEMENTED();
+    return NULL;

[sky, 2016/02/24 19:18:48]

nullptr (here and 54).

[gsennton, 2016/02/25 17:08:04]

Done.

+  }
+
+  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
+    NOTIMPLEMENTED();
+    return NULL;
+  }
+
+  gfx::Display GetPrimaryDisplay() const override {
+    gfx::DeviceDisplayInfo device_info;
+    return DisplayFromDeviceDisplayInfo(device_info);
+  }
+
+  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
+    if (view) {
+      return DisplayFromDeviceDisplayInfo(
+          view->GetWindowAndroid()->GetDeviceDisplayInfo());
+    } else {

[sky, 2016/02/24 19:18:48]

nit: no else after a return (see style guide).

[gsennton, 2016/02/25 17:08:04]

Done.

+      return GetPrimaryDisplay();
+    }
+  }
+
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
+    return GetPrimaryDisplay();
+  }
+
+  int GetNumDisplays() const override { return 1; }
+
+  std::vector<gfx::Display> GetAllDisplays() const override {
+    return std::vector<gfx::Display>(1, GetPrimaryDisplay());
+  }
+
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
+    return GetPrimaryDisplay();
+  }
+
+  void AddObserver(gfx::DisplayObserver* observer) override {
+    // no display change on Android.
+  }
+
+  void RemoveObserver(gfx::DisplayObserver* observer) override {
+    // no display change on Android.
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScreenAndroid);
+};
+
+gfx::Screen* CreateScreenAndroid() {
+  return new ScreenAndroid;
+}
+
+}  // namespace ui