Cache DeviceDisplayInfo data in shared structure on native side to avoid frequent JNI calls.

ui/gfx/android/shared_device_display_info.cc

+// Copyright (c) 2012 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"
+
+using base::android::AttachCurrentThread;
+using base::android::ScopedJavaLocalRef;
+
+void UpdateSharedDeviceDisplayInfo(JNIEnv* env,

[Alexei Svitkine (slow), 2013/10/15 15:13:07]

Surround this with the anon namespace (it can still be in the gfx namespace so
it doesn't need to have gfx:: when calling the class), like so:

namespace gfx {

namespace {

...

}  // namespace

...

}  // namespace gfx

[ostap, 2013/10/15 19:41:27]

If I do so it is not visible from JNI. 
I get this:
gen/ui/gfx/jni/DeviceDisplayInfo_jni.h:30:13: error: 'void
UpdateSharedDeviceDisplayInfo(JNIEnv*, jobject, jint, jint, jint, jint,
jdouble)' declared 'static' but never defined [-Werror=unused-function]

And I didn't find any place that includes JNI functions into anon namespace.

[Alexei Svitkine (slow), 2013/10/22 19:15:24]

Got it. Then, please re-add the static keyword to this and add a comment
explaining it's done that way for JNI.

+                                   jobject obj,
+                                   jint display_height,
+                                   jint display_width,
+                                   jint bits_per_pixel,
+                                   jint bits_per_component,
+                                   jdouble dip_scale) {
+  gfx::SharedDeviceDisplayInfo::InvokeUpdate(env, obj, display_height,
+      display_width, bits_per_pixel, bits_per_component, dip_scale);
+}
+
+namespace gfx {
+
+int SharedDeviceDisplayInfo::GetDisplayHeight() {

[Alexei Svitkine (slow), 2013/10/15 18:46:47]

How about making these non-static and to be used through the singleton?

Then, they can be simpler:

int SharedDeviceDisplayInfo::GetDisplayHeight() {
  base::AutoLock(lock_);
  return display_height_;
}

And have it be called via:

SharedDeviceDisplayInfo::GetInstance()->GetDisplayHeight()

Then you can make the GetInstance() function public like other singletons and
remove the extra friend decl.

This matches more closely how other singletons are used in Chromium.

+  SharedDeviceDisplayInfo* instance = GetInstance();
+  base::AutoLock(instance->lock_);
+  return instance->display_height_;
+}
+
+int SharedDeviceDisplayInfo::GetDisplayWidth() {
+  SharedDeviceDisplayInfo* instance = GetInstance();
+  base::AutoLock(instance->lock_);
+  return instance->display_width_;
+}
+
+int SharedDeviceDisplayInfo::GetBitsPerPixel() {
+  SharedDeviceDisplayInfo* instance = GetInstance();
+  base::AutoLock(instance->lock_);
+  return instance->bits_per_pixel_;
+}
+
+int SharedDeviceDisplayInfo::GetBitsPerComponent() {
+  SharedDeviceDisplayInfo* instance = GetInstance();
+  base::AutoLock(instance->lock_);
+  return instance->bits_per_component_;
+}
+
+double SharedDeviceDisplayInfo::GetDIPScale() {
+  SharedDeviceDisplayInfo* instance = GetInstance();
+  base::AutoLock(instance->lock_);
+  return instance->dip_scale_;
+}
+
+void SharedDeviceDisplayInfo::InvokeUpdate(JNIEnv* env,
+                                           jobject obj,
+                                           jint display_height,
+                                           jint display_width,
+                                           jint bits_per_pixel,
+                                           jint bits_per_component,
+                                           jdouble dip_scale) {
+  SharedDeviceDisplayInfo* instance = SharedDeviceDisplayInfo::GetInstance();
+  base::AutoLock(instance->lock());
+
+  instance->UpdateDisplayInfo(env, obj, display_height,
+      display_width, bits_per_pixel, bits_per_component, dip_scale);
+}
+
+void SharedDeviceDisplayInfo::UpdateDisplayInfo(JNIEnv* env,
+                                                jobject jobj,
+                                                jint display_height,
+                                                jint display_width,
+                                                jint bits_per_pixel,
+                                                jint bits_per_component,
+                                                jdouble dip_scale) {
+  display_height_ = static_cast<int>(display_height);
+  display_width_ = static_cast<int>(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);
+}
+
+SharedDeviceDisplayInfo* SharedDeviceDisplayInfo::GetInstance() {
+  return Singleton<SharedDeviceDisplayInfo>::get();
+}
+
+SharedDeviceDisplayInfo::SharedDeviceDisplayInfo() {
+  JNIEnv* env = 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_getBitsPerPixel(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getBitsPerComponent(env, j_device_info_.obj()),
+      Java_DeviceDisplayInfo_getDIPScale(env, j_device_info_.obj()));
+}
+
+bool SharedDeviceDisplayInfo::RegisterSharedDeviceDisplayInfo(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+}  // namespace gfx