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_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
@@ skipping 123 matching lines @@
   mouse_event.x = x;
   mouse_event.y = y;
   mouse_event.windowX = x;
   mouse_event.windowY = y;
   mouse_event.timeStampSeconds = timestamp;
   mouse_event.clickCount = 1;
   mouse_event.modifiers = 0;
 
   return mouse_event;
 }
-
 }  // 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,
@@ skipping 52 matching lines @@
   }
   g_instance = nullptr;
   gl::init::ClearGLBindings();
 }
 
 void VrShell::SetDelegate(JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     const base::android::JavaParamRef<jobject>& delegate) {
   base::AutoLock lock(gvr_init_lock_);
   delegate_ = VrShellDelegate::GetNativeDelegate(env, delegate);
-  if (gvr_api_) {
+  if (swap_chain_.get()) {
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
                               delegate_->GetDeviceProvider(),
                               weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 enum class ViewerType {
   UNKNOWN_TYPE = 0,
   CARDBOARD = 1,
   DAYDREAM = 2,
   VIEWER_TYPE_MAX,
 };
 
 void VrShell::GvrInit(JNIEnv* env,
                       const JavaParamRef<jobject>& obj,
                       jlong native_gvr_api) {
-  base::AutoLock lock(gvr_init_lock_);
-
   // set the initial webvr state
   metrics_helper_->SetVRActive(true);
 
   gvr_api_ =
       gvr::GvrApi::WrapNonOwned(reinterpret_cast<gvr_context*>(native_gvr_api));
   // TODO(klausw,crbug.com/655722): should report OnGvrDelegateReady here once
   // we switch to using a WebVR render surface. We currently need to wait for
   // the compositor window's size to be known first. See also
   // ContentSurfaceChanged.
   controller_.reset(
@@ skipping 15 matching lines @@
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("VRViewerType", static_cast<int>(viewerType),
       static_cast<int>(ViewerType::VIEWER_TYPE_MAX));
 }
 
 void VrShell::InitializeGl(JNIEnv* env,
                            const JavaParamRef<jobject>& obj,
                            jint content_texture_handle,
                            jint ui_texture_handle) {
+  base::AutoLock lock(gvr_init_lock_);
   CHECK(gl::GetGLImplementation() != gl::kGLImplementationNone ||
         gl::init::InitializeGLOneOff());
 
   content_texture_id_ = content_texture_handle;
   ui_texture_id_ = ui_texture_handle;
 
   // While WebVR is going through the compositor path, it shares
   // the same texture ID. This will change once it gets its own
   // surface, but store it separately to avoid future confusion.
   // TODO(klausw,crbug.com/655722): remove this.
@@ skipping 55 matching lines @@
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
   buffer_viewport_list_->GetBufferViewport(GVR_LEFT_EYE,
                                            webvr_left_viewport_.get());
   webvr_left_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 
   webvr_right_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            webvr_right_viewport_.get());
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
+
+  if (delegate_) {
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
+                              delegate_->GetDeviceProvider(),
+                              weak_ptr_factory_.GetWeakPtr()));
+  }
 }
 
 void VrShell::UpdateController(const gvr::Vec3f& forward_vector) {
   controller_->UpdateState();
 
 #if defined(ENABLE_VR_SHELL)
   // Note that button up/down state is transient, so IsButtonUp only returns
   // true for a single frame (and we're guaranteed not to miss it).
   if (controller_->IsButtonUp(
           gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP)) {
@@ skipping 98 matching lines @@
     if (distance_to_plane > 0 && distance_to_plane < closest_element_distance) {
       float x = rect_2d_point.x + 0.5f;
       float y = 0.5f - rect_2d_point.y;
       bool is_inside = x >= 0.0f && x < 1.0f && y >= 0.0f && y < 1.0f;
       if (!is_inside)
         continue;
 
       closest_element_distance = distance_to_plane;
       Rectf pixel_rect;
       if (plane->content_quad) {
-        pixel_rect = {0, 0, content_tex_width_, content_tex_height_};
+        pixel_rect = {0, 0, content_tex_css_width_, content_tex_css_height_};
       } else {
         pixel_rect = {plane->copy_rect.x, plane->copy_rect.y,
                       plane->copy_rect.width, plane->copy_rect.height};
       }
       pixel_x = pixel_rect.width * x + pixel_rect.x;
       pixel_y = pixel_rect.height * y + pixel_rect.y;
 
       target_point_ = plane_intersection_point;
       target_element_ = plane.get();
       input_target = plane->content_quad ? content_input_manager_.get()
@@ skipping 217 matching lines @@
   render_size_primary_webvr_.width = width;
   render_size_primary_webvr_.height = height;
   // TODO(klausw,crbug.com/655722): set the WebVR render surface size here once
   // we have that.
 }
 
 gvr::Sizei VrShell::GetWebVRCompositorSurfaceSize() {
   // This is a stopgap while we're using the WebVR compositor rendering path.
   // TODO(klausw,crbug.com/655722): Remove this method and member once we're
   // using a separate WebVR render surface.
-  return content_tex_pixels_for_webvr_;
+  return content_tex_physical_size_;
 }
 
 
 void VrShell::DrawUiView(const gvr::Mat4f* head_pose,
                          const std::vector<const ContentRectangle*>& elements,
                          const gvr::Sizei& render_size, int viewport_offset) {
   TRACE_EVENT0("gpu", "VrShell::DrawUiView");
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(
         eye + viewport_offset, buffer_viewport_.get());
@@ skipping 25 matching lines @@
 void VrShell::DrawElements(
     const gvr::Mat4f& render_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto& rect : elements) {
     Rectf copy_rect;
     jint texture_handle;
     if (rect->content_quad) {
       copy_rect = {0, 0, 1, 1};
       texture_handle = content_texture_id_;
     } else {
-      copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_width_;
-      copy_rect.y = static_cast<float>(rect->copy_rect.y) / ui_tex_height_;
+      copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_css_width_;
+      copy_rect.y = static_cast<float>(rect->copy_rect.y) / ui_tex_css_height_;
       copy_rect.width = static_cast<float>(rect->copy_rect.width) /
-          ui_tex_width_;
+          ui_tex_css_width_;
       copy_rect.height = static_cast<float>(rect->copy_rect.height) /
-          ui_tex_height_;
+          ui_tex_css_height_;
       texture_handle = ui_texture_id_;
     }
     gvr::Mat4f transform = MatrixMul(render_matrix, rect->transform.to_world);
     vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
         texture_handle, transform, copy_rect);
   }
 }
 
 void VrShell::DrawCursor(const gvr::Mat4f& render_matrix) {
   gvr::Mat4f mat;
@@ skipping 150 matching lines @@
 void VrShell::UpdateWebVRTextureBounds(const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds) {
   webvr_left_viewport_->SetSourceUv(left_bounds);
   webvr_right_viewport_->SetSourceUv(right_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) {
-  TRACE_EVENT0("gpu", "VrShell::ContentSurfaceChanged");
-  // If we have a delegate, must trigger "ready" callback one time only.
-  // Do so the first time we got a nonzero size. (This assumes it doesn't
-  // change, but once we get resize ability we'll no longer need this hack.)
-  // TODO(klausw,crbug.com/655722): remove when we have surface support.
-  bool delegate_not_ready = delegate_ && !content_tex_pixels_for_webvr_.width;
-
-  content_compositor_->SurfaceChanged((int)width, (int)height, surface);
-  content_tex_pixels_for_webvr_.width = width;
-  content_tex_pixels_for_webvr_.height = height;
-  float scale_factor = display::Screen::GetScreen()
-      ->GetPrimaryDisplay().device_scale_factor();
-  content_tex_width_ = width / scale_factor;
-  content_tex_height_ = height / scale_factor;
-
-  // TODO(klausw,crbug.com/655722): move this back to GvrInit once we have
-  // our own WebVR surface.
-  if (delegate_ && delegate_not_ready) {
-    main_thread_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&device::GvrDeviceProvider::OnGvrDelegateReady,
-                              delegate_->GetDeviceProvider(),
-                              weak_ptr_factory_.GetWeakPtr()));
-  }
+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);
-  float scale_factor = display::Screen::GetScreen()
-      ->GetPrimaryDisplay().device_scale_factor();
-  ui_tex_width_ = width / scale_factor;
-  ui_tex_height_ = height / scale_factor;
+void VrShell::ContentBoundsChanged(JNIEnv* env,
+                                   const JavaParamRef<jobject>& object,
+                                   jint width, jint height, jfloat dpr) {
+  TRACE_EVENT0("gpu", "VrShell::ContentBoundsChanged");
+  content_tex_physical_size_.width = width;
+  content_tex_physical_size_.height = height;
+  content_tex_css_width_ = width / dpr;
+  content_tex_css_height_ = height / dpr;
+
+  content_compositor_->SetWindowBounds(width, height);
+  main_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()
+      ->WasResized();
+}
+
+void VrShell::UIBoundsChanged(JNIEnv* env,
+                              const JavaParamRef<jobject>& object,
+                              jint width, jint height, jfloat dpr) {
+  // TODO(mthiesse): Synchronize these values changing with the renderer
+  // actually sending us a texture with the updated size somehow.

[bshe, 2016/11/30 23:00:46]

This TODO is confusing. Do you mean you want to synchronize the values with
renderer? IIRC, WasResized should sync these value on renderer side though IPC.

[mthiesse, 2016/11/30 23:25:05]

Moved into MainFrameWasResized, and updated the comment.

+  ui_tex_css_width_ = width / dpr;
+  ui_tex_css_height_ = height / dpr;
+
+  ui_compositor_->SetWindowBounds(width, height);
+  ui_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->WasResized();
 }
 
 UiScene* VrShell::GetScene() {
   return scene_.get();
 }
 
 UiInterface* VrShell::GetUiInterface() {
   return html_interface_.get();
 }
 
@@ skipping 46 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void VrShell::RenderViewHostChanged(content::RenderViewHost* old_host,
                                     content::RenderViewHost* new_host) {
   new_host->GetWidget()->GetView()->SetBackgroundColor(SK_ColorTRANSPARENT);
 }
 
+void VrShell::SetContentCssSize(float width, float height, float dpr) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_VrShellImpl_setContentCssSize(env, j_vr_shell_.obj(), width, height,
+                                     dpr);
+}
+
+void VrShell::SetUiCssSize(float width, float height, float dpr) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_VrShellImpl_setUiCssSize(env, j_vr_shell_.obj(), width, height, dpr);
+}
+
 // ----------------------------------------------------------------------------
 // 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,
            jboolean for_web_vr) {
   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),
       for_web_vr));
 }
 
 }  // namespace vr_shell