Decouple VR Shell DPR and CSS size from Physical Displays.

chrome/browser/android/vr_shell/vr_shell.cc

 // 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.
 
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gesture.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/screen_info.h"
 #include "jni/VrShellImpl_jni.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
+#include "ui/display/android/screen_android.h"
+#include "ui/display/display.h"
+#include "ui/gfx/android/device_display_info.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/init/gl_factory.h"
 
 using base::android::JavaParamRef;
+using base::android::ScopedJavaLocalRef;
 
 namespace {
 // Constant taken from treasure_hunt demo.
 static constexpr long kPredictionTimeWithoutVsyncNanos = 50000000;
 
 static constexpr float kZNear = 0.1f;
 static constexpr float kZFar = 1000.0f;
 
 static constexpr gvr::Vec3f kDesktopPositionDefault = {0.0f, 0.0f, -2.0f};
 static constexpr float kDesktopHeightDefault = 1.6f;
@@ skipping 40 matching lines @@
 // into geometry (they ignore the Z buffer), leading to odd effects
 // if they are far away.
 static constexpr vr_shell::Recti kWebVrWarningTransientRect = {
   0, 128, 512, 256};
 static constexpr vr_shell::Recti kWebVrWarningPermanentRect = {0, 0, 512, 128};
 static constexpr float kWebVrWarningDistance = 0.7f;  // meters
 static constexpr float kWebVrWarningPermanentAngle = 16.3f;  // degrees up
 // How long the transient warning needs to be displayed.
 static constexpr int64_t kWebVrWarningSeconds = 30;
 
+static constexpr int kContentDisplayId = 1;
+static constexpr int kUiDisplayId = 2;
+
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 float Distance(const gvr::Vec3f& vec1, const gvr::Vec3f& vec2) {
   float xdiff = (vec1.x - vec2.x);
   float ydiff = (vec1.y - vec2.y);
   float zdiff = (vec1.z - vec2.z);
   float scale = xdiff * xdiff + ydiff * ydiff + zdiff * zdiff;
   return std::sqrt(scale);
@@ skipping 15 matching lines @@
     quat.qw = 0.0f;
   } else {
     quat.qx = vec.y;
     quat.qy = -vec.x;
     quat.qz = 0.0f;
     vr_shell::NormalizeQuat(quat);
   }
   return quat;
 }
 
+void populateDisplayWithDefaults(display::Display& display, float dpr,
+                                 gfx::Rect bounds) {
+  gfx::DeviceDisplayInfo device_info;
+  display.SetScaleAndBounds(dpr, bounds);
+  display.SetRotationAsDegree(device_info.GetRotationDegrees());
+  display.set_color_depth(device_info.GetBitsPerPixel());
+  display.set_depth_per_component(device_info.GetBitsPerComponent());
+  display.set_is_monochrome(device_info.GetBitsPerComponent() == 0);
+}
+
 }  // namespace
 
 namespace vr_shell {
 
 VrShell::VrShell(JNIEnv* env, jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window)
     : desktop_screen_tilt_(kDesktopScreenTiltDefault),
@@ skipping 20 matching lines @@
 
   gvr::Mat4f identity;
   SetIdentityM(identity);
   webvr_head_pose_.resize(kPoseRingBufferSize, identity);
 }
 
 void VrShell::UpdateCompositorLayers(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   content_compositor_->SetLayer(main_contents_);
   ui_compositor_->SetLayer(ui_contents_);
+
+  // TODO(mthiesse): These are temporary placeholders until the UI js is
+  // updated to call these functions.
+  SetUiCssSize(1920, 1080, 1.0);
+  SetContentCssSize(1280, 720, 1.0);
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 void VrShell::LoadUIContent() {
   GURL url(kVrShellUIURL);
   ui_contents_->GetController().LoadURL(
       url, content::Referrer(),
       ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string(""));
 }
 
 bool RegisterVrShell(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VrShell::~VrShell() {
+  display::ScreenAndroid* screen = reinterpret_cast<display::ScreenAndroid*>(
+        display::Screen::GetScreen());
+  screen->ClearDisplayForWindow(ui_contents_->GetNativeView());
+  screen->ClearDisplayForWindow(main_contents_->GetNativeView());
   g_instance = nullptr;
   gl::init::ClearGLBindings();
 }
 
 void VrShell::SetDelegate(JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     const base::android::JavaParamRef<jobject>& delegate) {
   delegate_ = VrShellDelegate::getNativeDelegate(env, delegate);
 }
 
@@ skipping 579 matching lines @@
 void VrShell::UpdateWebVRTextureBounds(
     int eye, float left, float top, float width, float height) {
   gvr::Rectf bounds = { left, top, width, height };
   vr_shell_renderer_->GetWebVrRenderer()->UpdateTextureBounds(eye, bounds);
 }
 
 gvr::GvrApi* VrShell::gvr_api() {
   return gvr_api_.get();
 }
 
-void VrShell::ContentSurfaceChanged(JNIEnv* env,
-                                    const JavaParamRef<jobject>& object,
-                                    jint width,
-                                    jint height,
-                                    const JavaParamRef<jobject>& surface) {
-  content_compositor_->SurfaceChanged((int)width, (int)height, surface);
-  content::ScreenInfo result;
-  main_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->
-      GetScreenInfo(&result);
-  float dpr = result.device_scale_factor;
-  scene_->GetUiElementById(kBrowserUiElementId)->copy_rect =
-      { 0, 0, width / dpr, height / dpr };
+void VrShell::SurfacesChanged(JNIEnv* env,
+                              const JavaParamRef<jobject>& object,
+                              const JavaParamRef<jobject>& content_surface,
+                              const JavaParamRef<jobject>& ui_surface) {
+  content_compositor_->SurfaceChanged(content_surface);
+  ui_compositor_->SurfaceChanged(ui_surface);
 }
 
-void VrShell::UiSurfaceChanged(JNIEnv* env,
-                               const JavaParamRef<jobject>& object,
-                               jint width,
-                               jint height,
-                               const JavaParamRef<jobject>& surface) {
-  ui_compositor_->SurfaceChanged((int)width, (int)height, surface);
-  content::ScreenInfo result;
-  ui_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->GetScreenInfo(
-      &result);
-  ui_tex_width_ = width / result.device_scale_factor;
-  ui_tex_height_ = height / result.device_scale_factor;
+void VrShell::ContentBoundsChanged(JNIEnv* env,
+                                   const JavaParamRef<jobject>& object,
+                                   jint width, jint height) {
+  content_compositor_->SetWindowBounds(width, height);
+  main_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()
+      ->WasResized();
+}
+
+void VrShell::UIBoundsChanged(JNIEnv* env,
+                              const JavaParamRef<jobject>& object,
+                              jint width,
+                              jint height) {
+  ui_compositor_->SetWindowBounds(width, height);
+  ui_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->WasResized();
 }
 
 UiScene* VrShell::GetScene() {
   return scene_.get();
 }
 
 void VrShell::QueueTask(base::Callback<void()>& callback) {
   base::AutoLock lock(task_queue_lock_);
   task_queue_.push(callback);
 }
@@ skipping 30 matching lines @@
       controller.Reload(false);
       break;
     case ZOOM_OUT:  // Not handled yet.
     case ZOOM_IN:  // Not handled yet.
       break;
     default:
       NOTREACHED();
   }
 }
 
+void VrShell::SetContentCssSize(float width, float height, float dpr) {
+  const gfx::Rect bounds_in_pixels = gfx::Rect(gfx::ScaleToCeiledSize(
+      gfx::Size(width, height), dpr));
+  display::Display display(kContentDisplayId);
+
+  populateDisplayWithDefaults(display, dpr, bounds_in_pixels);
+
+  display::ScreenAndroid* screen = reinterpret_cast<display::ScreenAndroid*>(
+      display::Screen::GetScreen());
+  screen->SetDisplayForWindow(main_contents_->GetNativeView(), display);
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
+                                     dpr);
+
+  scene_->GetUiElementById(kBrowserUiElementId)->copy_rect =
+      { 0, 0, width, height };
+}
+
+void VrShell::SetUiCssSize(float width, float height, float dpr) {
+  const gfx::Rect bounds_in_pixels = gfx::Rect(gfx::ScaleToCeiledSize(
+      gfx::Size(width, height), dpr));
+  display::Display display(kUiDisplayId);
+
+  populateDisplayWithDefaults(display, dpr, bounds_in_pixels);
+
+  display::ScreenAndroid* screen = reinterpret_cast<display::ScreenAndroid*>(
+      display::Screen::GetScreen());
+  screen->SetDisplayForWindow(ui_contents_->GetNativeView(), display);
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_VrShellImpl_setUiCssSize(env, j_vr_shell_.obj(), width, height, dpr);
+
+  ui_tex_width_ = width;
+  ui_tex_height_ = height;
+}
+
 // ----------------------------------------------------------------------------
 // Native JNI methods
 // ----------------------------------------------------------------------------
 
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
            const JavaParamRef<jobject>& content_web_contents,
            jlong content_window_android,
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell