Android: Add support for returning real screen resolution.

ui/gfx/android/shared_device_display_info.cc

 // Copyright 2013 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.
 
 #include "ui/gfx/android/shared_device_display_info.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
 #include "jni/DeviceDisplayInfo_jni.h"
 
 namespace gfx {
 
 // static JNI call
 static void UpdateSharedDeviceDisplayInfo(JNIEnv* env,
                                           jobject obj,
                                           jint display_height,
                                           jint display_width,
+                                          jint real_display_height,
+                                          jint real_display_width,
                                           jint bits_per_pixel,
                                           jint bits_per_component,
                                           jdouble dip_scale,
                                           jint smallest_dip_width) {
   SharedDeviceDisplayInfo::GetInstance()->InvokeUpdate(env, obj,
-      display_height, display_width, bits_per_pixel, bits_per_component,
+      display_height, display_width,
+      real_display_height, real_display_width,
+      bits_per_pixel, bits_per_component,
       dip_scale, smallest_dip_width);
 }
 
 // static
 SharedDeviceDisplayInfo* SharedDeviceDisplayInfo::GetInstance() {
   return Singleton<SharedDeviceDisplayInfo>::get();
 }
 
 int SharedDeviceDisplayInfo::GetDisplayHeight() {
   base::AutoLock autolock(lock_);
   DCHECK_NE(0, display_height_);
   return display_height_;
 }
 
 int SharedDeviceDisplayInfo::GetDisplayWidth() {
   base::AutoLock autolock(lock_);
   DCHECK_NE(0, display_width_);
   return display_width_;
 }
 
+int SharedDeviceDisplayInfo::GetRealDisplayHeight() {
+  base::AutoLock autolock(lock_);
+  DCHECK_NE(0, real_display_height_);

[no sievers, 2013/12/20 19:32:45]

I think if you throw an exception in Java instead, then the JNI call below would
trip some native CHECK() or DCHECK() in the auto-generated JNI code.

[epennerAtGoogle, 2013/12/20 19:42:55]

Are you thinking we should just never call the function on ICS where it's not
supported (it would result in DCHECK)? If we added a 'hasPhysicalDimensions'
function this would work.

See my response to Ruslan on that, and let me know if that's what you would
like.

[no sievers, 2013/12/20 19:51:19]

I think you can actually do the same/similar check in the native code here and
not call into Java:

base::android::BuildInfo::GetInstance()->sdk_int() >= 17 // is JB MR1 or greater

+  return real_display_height_;
+}
+
+int SharedDeviceDisplayInfo::GetRealDisplayWidth() {
+  base::AutoLock autolock(lock_);
+  DCHECK_NE(0, real_display_width_);
+  return real_display_width_;
+}
+
 int SharedDeviceDisplayInfo::GetBitsPerPixel() {
   base::AutoLock autolock(lock_);
   DCHECK_NE(0, bits_per_pixel_);
   return bits_per_pixel_;
 }
 
 int SharedDeviceDisplayInfo::GetBitsPerComponent() {
   base::AutoLock autolock(lock_);
   DCHECK_NE(0, bits_per_component_);
   return bits_per_component_;
@@ skipping 13 matching lines @@
 
 // static
 bool SharedDeviceDisplayInfo::RegisterSharedDeviceDisplayInfo(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 void SharedDeviceDisplayInfo::InvokeUpdate(JNIEnv* env,
                                            jobject obj,
                                            jint display_height,
                                            jint display_width,
+                                           jint real_display_height,
+                                           jint real_display_width,
                                            jint bits_per_pixel,
                                            jint bits_per_component,
                                            jdouble dip_scale,
                                            jint smallest_dip_width) {
   base::AutoLock autolock(lock_);
 
-  UpdateDisplayInfo(env, obj, display_height,
-      display_width, bits_per_pixel, bits_per_component, dip_scale,
+  UpdateDisplayInfo(env, obj,
+      display_height, display_width,
+      real_display_height, real_display_width,
+      bits_per_pixel, bits_per_component, dip_scale,
       smallest_dip_width);
 }
 
 SharedDeviceDisplayInfo::SharedDeviceDisplayInfo()
     : display_height_(0),
       display_width_(0),
       bits_per_pixel_(0),
       bits_per_component_(0),
       dip_scale_(0),
       smallest_dip_width_(0) {
   JNIEnv* env = base::android::AttachCurrentThread();
   j_device_info_.Reset(
       Java_DeviceDisplayInfo_createWithListener(env,
           base::android::GetApplicationContext()));
   UpdateDisplayInfo(env, j_device_info_.obj(),
       Java_DeviceDisplayInfo_getDisplayHeight(env, j_device_info_.obj()),
       Java_DeviceDisplayInfo_getDisplayWidth(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getRealDisplayHeight(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getRealDisplayWidth(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()));
 }
 
 SharedDeviceDisplayInfo::~SharedDeviceDisplayInfo() {
 }
 
 void SharedDeviceDisplayInfo::UpdateDisplayInfo(JNIEnv* env,
                                                 jobject jobj,
                                                 jint display_height,
                                                 jint display_width,
+                                                jint real_display_height,
+                                                jint real_display_width,
                                                 jint bits_per_pixel,
                                                 jint bits_per_component,
                                                 jdouble dip_scale,
                                                 jint smallest_dip_width) {
   display_height_ = static_cast<int>(display_height);
   display_width_ = static_cast<int>(display_width);
+  real_display_height_ = static_cast<int>(real_display_height);
+  real_display_width_ = static_cast<int>(real_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);
 }
 
 }  // namespace gfx