Make WebView work for external displays (over Presentations).

ui/gfx/android/device_display_info.cc

Index: ui/gfx/android/device_display_info.cc
diff --git a/ui/gfx/android/device_display_info.cc b/ui/gfx/android/device_display_info.cc
index 4d2c80c09d6c1d9c4c87102e0138901222943fb9..e55d67fa7d18d9cf38b2c7e853c9ac9f504c2d09 100644
--- a/ui/gfx/android/device_display_info.cc
+++ b/ui/gfx/android/device_display_info.cc
@@ -2,53 +2,104 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "jni/DeviceDisplayInfo_jni.h"
 #include "ui/gfx/android/device_display_info.h"
 
-#include "base/logging.h"
-#include "ui/gfx/android/shared_device_display_info.h"
-
 namespace gfx {
 
+DeviceDisplayInfo::DeviceDisplayInfo(

[jdduke (slow), 2015/06/16 15:01:28]

So, there's an assumption currently that creating a DeviceDisplayInfo is a
trivially cheap operation, but that's no longer the case. Do you have a sense
for how frequently this is created? 1x/frame? 10x/frame? 1x/pageload?

[gsennton, 2015/06/17 11:40:36]

Potentially stupid question from my part -- why is creating a DeviceDisplayInfo
no longer a cheap operation?

I do not know how often this happens, is there a good way of measuring this?

[jdduke (slow), 2015/06/17 15:56:04]

Now we have to construct a new Java object, and call ~10 JNI methods. Before,
creating a DeviceDisplayInfo instance was a no-op. A cursory grep shows a few
places where we create throw-away DeviceDisplayInfo instances, e.g.,
tab_android.cc, compositor_impl_android.cc, etc... I don't want us to be doing
all this extra work if we can avoid it, maybe those callsites can be updated to
pull the info from the WindowAndroid object?
Well, you can just add some log statements here and see how frequently it's
called when you load a new page, scroll around, etc...

[boliu, 2015/06/17 16:02:20]

The bigger issue is to avoid gc pauses. Eg during each frame, somethings can be
creating native DeviceDispalyInfo on the stack, which just creates a java object
and throws it away. So then during a fling, there's jvm gc pause every few
seconds, which sucks.

JNI calls aren't *that* bad..

[gsennton, 2015/06/18 11:37:22]

Oh, right, I missed this entirely -- if jni calls are expensive we could just
have the java-side send all the values in one single function call...?

[gsennton, 2015/06/25 13:59:58]

To answer the original question here,

Chrome:
When starting Chrome I see 9 uses of the java DeviceDisplayInfo constructor: 7
using the default DeviceDisplayInfo constructor from the native side, 1 using
the WindowAndroid and 1 from the java side.
When clicking a link and loading a new page the java constructor is used twice
(both from GetPrimaryDisplay from the native side).
Scrolling hits RenderWidgetHostViewAndroid::GetScreenInfo a lot and afaict
nothing else (with this patch that callpath uses the cached copy in
WindowAndroid).
Changing the screen orientation updates the WindowAndroid cache once and then
hits RenderWidgetHostViewAndroid::GetScreenInfo a lot (probably to adjust the
scroll?)


WebView in Browser:
(WebView in a simple test app is similar except each screen orientation change
seems to recreate WebView)
Startup: 8 constructor calls, 6 from the DeviceDisplayInfo default constructor,
1 for WindowAndroid, 1 from the java side
Scrolling and clicking links seem to always hit the WindowAndroid cache.
Changing the screen orientation behaves similar to Chrome.

+    base::android::ScopedJavaLocalRef<jobject> context) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  j_device_info_.Reset(
+      Java_DeviceDisplayInfo_create(env, context.obj()));
+  FetchDisplayInfoFromJava(env);
+}
+
 DeviceDisplayInfo::DeviceDisplayInfo() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  j_device_info_.Reset(

[jdduke (slow), 2015/06/17 15:56:04]

It's a shame to have to create a Java object here that's really only used once
(upon creation).

[gsennton, 2015/06/18 11:37:22]

We could cache the primary display info in some shared_device_display_info class
and let that class add an observer to ScreenOrientationListener as well? Then we
should only need to create this java object once.

+      Java_DeviceDisplayInfo_create(env,
+        base::android::GetApplicationContext()));
+  FetchDisplayInfoFromJava(env);
 }
 
 DeviceDisplayInfo::~DeviceDisplayInfo() {
 }
 
+void DeviceDisplayInfo::FetchDisplayInfoFromJava(JNIEnv* env) {
+  UpdateDisplayInfo(
+      Java_DeviceDisplayInfo_getDisplayHeight(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getDisplayWidth(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getPhysicalDisplayHeight(env,
+                                                      j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getPhysicalDisplayWidth(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getBitsPerPixel(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getBitsPerComponent(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getDIPScale(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getSmallestDIPWidth(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getRotationDegrees(env, j_device_info_.obj()));
+}
+
+void DeviceDisplayInfo::UpdateDisplayInfo(jint display_height,
+                                          jint display_width,
+                                          jint physical_display_height,
+                                          jint physical_display_width,
+                                          jint bits_per_pixel,
+                                          jint bits_per_component,
+                                          jdouble dip_scale,
+                                          jint smallest_dip_width,
+                                          jint rotation_degrees) {
+  display_height_ = static_cast<int>(display_height);
+  display_width_ = static_cast<int>(display_width);
+  physical_display_height_ = static_cast<int>(physical_display_height);
+  physical_display_width_ = static_cast<int>(physical_display_width);
+  bits_per_pixel_ = static_cast<int>(bits_per_pixel);
+  bits_per_component_ = static_cast<int>(bits_per_component);
+  dip_scale_ = static_cast<double>(dip_scale);
+  smallest_dip_width_ = static_cast<int>(smallest_dip_width);
+  rotation_degrees_ = static_cast<int>(rotation_degrees);
+}
+
+// TODO all these can be const if we only return the stored values here
 int DeviceDisplayInfo::GetDisplayHeight() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetDisplayHeight();
+  return display_height_;
 }
 
 int DeviceDisplayInfo::GetDisplayWidth() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetDisplayWidth();
+  return display_width_;
 }
 
 int DeviceDisplayInfo::GetPhysicalDisplayHeight() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetPhysicalDisplayHeight();
+  return physical_display_height_;
 }
 
 int DeviceDisplayInfo::GetPhysicalDisplayWidth() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetPhysicalDisplayWidth();
+  return physical_display_width_;
 }
 
 int DeviceDisplayInfo::GetBitsPerPixel() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetBitsPerPixel();
+  return bits_per_pixel_;
 }
 
 int DeviceDisplayInfo::GetBitsPerComponent() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetBitsPerComponent();
+  return bits_per_component_;
 }
 
 double DeviceDisplayInfo::GetDIPScale() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetDIPScale();
+  return dip_scale_;
 }
 
 int DeviceDisplayInfo::GetSmallestDIPWidth() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetSmallestDIPWidth();
+  return smallest_dip_width_;
 }
 
 int DeviceDisplayInfo::GetRotationDegrees() {
-  return SharedDeviceDisplayInfo::GetInstance()->GetRotationDegrees();
+  return rotation_degrees_;
+}
+
+// static
+bool DeviceDisplayInfo::RegisterDeviceDisplayInfo(JNIEnv* env) {
+  return RegisterNativesImpl(env);
 }
 
 }  // namespace gfx