[vr] Reposition / resize via window frame

Previously, we would reposition using the backplane, but with this
change, we introduce a frame around the content window that can be
dragged.

This change also fixes the positioning of the fullscreen toast and
the close button so that they adapt to a resized window.

It also removes some now-useless code for setting the center
position of a gradient quad and fixes a bug in the "bounds contain
children" code where we weren't updating positioning correctly
for children with asymmetric padding.

Bug: 799270
Cq-Include-Trybots: luci.chromium.try:linux_optional_gpu_tests_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_vr;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: Ia6d9759b3e8b6fc80bc0d1ae2f0c739cc9cd0f7f
Reviewed-on: https://chromium-review.googlesource.com/967350
Commit-Queue: Ian Vollick <vollick@chromium.org>
Reviewed-by: Christopher Grant <cjgrant@chromium.org>
Cr-Commit-Position: refs/heads/master@{#544061}

chrome/browser/vr/elements/full_screen_rect.cc

@@ -16,7 +16,7 @@ void FullScreenRect::Render(UiElementRenderer* renderer,
                             const CameraModel& model) const {
   gfx::Transform m;
   m.Scale3d(2.0f, 2.0f, 1.0f);
-  renderer->DrawGradientQuad(m, edge_color(), center_color(), gfx::PointF(),
+  renderer->DrawGradientQuad(m, edge_color(), center_color(),
                              computed_opacity(), size(), corner_radii());
 }
 

chrome/browser/vr/elements/rect.cc

@@ -42,8 +42,25 @@ void Rect::NotifyClientColorAnimated(SkColor color,
 
 void Rect::Render(UiElementRenderer* renderer, const CameraModel& model) const {
   renderer->DrawGradientQuad(model.view_proj_matrix * world_space_transform(),
-                             edge_color_, center_color_, center_point_,
-                             computed_opacity(), size(), corner_radii());
+                             edge_color_, center_color_,
+                             computed_opacity() * local_opacity_, size(),
+                             corner_radii());
+}
+
+void Rect::SetLocalOpacity(float opacity) {
+  animation().TransitionFloatTo(last_frame_time(), LOCAL_OPACITY,
+                                local_opacity_, opacity);
+}
+
+void Rect::NotifyClientFloatAnimated(float value,
+                                     int target_property_id,
+                                     cc::KeyframeModel* keyframe_model) {
+  if (target_property_id == LOCAL_OPACITY) {
+    local_opacity_ = value;
+  } else {
+    UiElement::NotifyClientFloatAnimated(value, target_property_id,
+                                         keyframe_model);
+  }
 }
 
 }  // namespace vr

chrome/browser/vr/elements/rect.h

@@ -38,18 +38,18 @@ class Rect : public UiElement {
   void Render(UiElementRenderer* renderer,
               const CameraModel& model) const override;
 
-  void set_center_point(const gfx::PointF& center_point) {
-    center_point_ = center_point;
-  }
+  void SetLocalOpacity(float opacity);
+
+  void NotifyClientFloatAnimated(float value,
+                                 int target_property_id,
+                                 cc::KeyframeModel* keyframe_model) override;
 
  private:
   SkColor center_color_ = SK_ColorWHITE;
   SkColor edge_color_ = SK_ColorWHITE;
 
-  // This is the center point of the gradient, in aspect-corrected, local
-  // coordinates. That is, {0, 0} is always the center of the quad, and the
-  // longer extent always varies between -0.5 and 0.5.
-  gfx::PointF center_point_;
+  // This value is not inherited by descendants.
+  float local_opacity_ = 1.0f;
 
   DISALLOW_COPY_AND_ASSIGN(Rect);
 };

chrome/browser/vr/elements/resizer.cc

@@ -77,4 +77,13 @@ bool Resizer::OnBeginFrame(const base::TimeTicks& time,
   return false;
 }
 
+#ifndef NDEBUG
+void Resizer::DumpGeometry(std::ostringstream* os) const {
+  gfx::Transform t = LocalTransform();
+  gfx::Vector3dF right = {1, 0, 0};
+  t.TransformVector(&right);
+  *os << "s(" << right.x() << ") ";
+}
+#endif
+
 }  // namespace vr

chrome/browser/vr/elements/resizer.h

@@ -29,6 +29,10 @@ class Resizer : public UiElement {
   void SetEnabled(bool enabled);
   void Reset();
 
+#ifndef NDEBUG
+  void DumpGeometry(std::ostringstream* os) const override;
+#endif
+
  private:
   gfx::Transform LocalTransform() const override;
   gfx::Transform GetTargetLocalTransform() const override;

chrome/browser/vr/elements/shadow.cc

@@ -140,7 +140,7 @@ void Shadow::Render(UiElementRenderer* renderer,
 void Shadow::LayOutChildren() {
   DCHECK(!children().empty());
   gfx::Point3F p;
-  children().front()->LocalTransform().TransformPoint(&p);
+  children().back()->LocalTransform().TransformPoint(&p);
   DCHECK_GE(kMaximumChildDepth, p.z());
   depth_ = base::ClampToRange(p.z() / kMaximumChildDepth, 0.0f, 1.0f);
   // This is an arbitrary function that quickly accelerates from 0 toward 1.
@@ -149,7 +149,7 @@ void Shadow::LayOutChildren() {
               gfx::Tween::FloatValueBetween(depth_, kYMinShadowGradientFactor,
                                             kYMaxShadowGradientFactor));
   if (children().size() == 1u)
-    set_corner_radius(children().front()->corner_radii().MaxRadius());
+    set_corner_radius(children().back()->corner_radii().MaxRadius());
 }
 
 Shadow::Renderer::Renderer()

chrome/browser/vr/elements/ui_element.cc

@@ -256,14 +256,6 @@ void UiElement::SetSize(float width, float height) {
 
 void UiElement::OnSetSize(const gfx::SizeF& size) {}
 
-gfx::SizeF UiElement::ContributedSize() const {
-  gfx::RectF bounds(size());
-  if (!bounds_contain_padding_) {
-    bounds.Inset(left_padding_, bottom_padding_, right_padding_, top_padding_);
-  }
-  return bounds.size();
-}
-
 void UiElement::SetVisible(bool visible) {
   SetOpacity(visible ? opacity_when_visible_ : 0.0);
 }
@@ -702,7 +694,13 @@ void UiElement::DoLayOutChildren() {
   bool requires_relayout = false;
   gfx::RectF bounds;
   for (auto& child : children_) {
-    gfx::SizeF size = child->ContributedSize();
+    gfx::RectF outer_bounds(child->size());
+    gfx::RectF inner_bounds(child->size());
+    if (!child->bounds_contain_padding_) {
+      inner_bounds.Inset(child->left_padding_, child->bottom_padding_,
+                         child->right_padding_, child->top_padding_);
+    }
+    gfx::SizeF size = inner_bounds.size();
     if (child->x_anchoring() != NONE || child->y_anchoring() != NONE) {
       DCHECK(!child->contributes_to_parent_bounds());
       requires_relayout = true;
@@ -711,7 +709,9 @@ void UiElement::DoLayOutChildren() {
         !child->contributes_to_parent_bounds()) {
       continue;
     }
-    gfx::Point3F child_center(child->local_origin());
+    gfx::Vector2dF delta =
+        outer_bounds.CenterPoint() - inner_bounds.CenterPoint();
+    gfx::Point3F child_center(child->local_origin() - delta);
     gfx::Vector3dF corner_offset(size.width(), size.height(), 0);
     corner_offset.Scale(-0.5);
     gfx::Point3F child_upper_left = child_center + corner_offset;

chrome/browser/vr/elements/ui_element.h

@@ -71,7 +71,7 @@ struct EventHandlers {
 struct HitTestRequest {
   gfx::Point3F ray_origin;
   gfx::Point3F ray_target;
-  float max_distance_to_plane;
+  float max_distance_to_plane = 1000.f;
 };
 
 // The result of performing a hit test.
@@ -226,12 +226,6 @@ class UiElement : public cc::AnimationTarget {
   void SetSize(float width, float hight);
   virtual void OnSetSize(const gfx::SizeF& size);
 
-  // Elements may report a different size to parents that resize to contain
-  // their children. Eg, for shadows.
-  // TODO(crbug.com/820507): change this to LayoutSize and update all layout
-  // code to make use of this instead of size().
-  gfx::SizeF ContributedSize() const;
-
   gfx::PointF local_origin() const { return local_origin_; }
 
   // These are convenience functions for setting the transform operations. They

chrome/browser/vr/elements/ui_element_name.cc

@@ -25,9 +25,10 @@ static const char* g_ui_element_name_strings[] = {
     "kWebVrRoot",
     "kWebVrViewportAwareRoot",
     "kContentResizer",
+    "kContentFrame",
+    "kContentFrameHitPlane",
     "kContentQuad",
     "kContentQuadShadow",
-    "kContentQuadRepositionButton",
     "kControllerRoot",
     "kControllerGroup",
     "kLaser",

chrome/browser/vr/elements/ui_element_name.h

@@ -24,9 +24,10 @@ enum UiElementName {
   kWebVrRoot,
   kWebVrViewportAwareRoot,
   kContentResizer,
+  kContentFrame,
+  kContentFrameHitPlane,
   kContentQuad,
   kContentQuadShadow,
-  kContentQuadRepositionButton,
   kControllerRoot,
   kControllerGroup,
   kLaser,

chrome/browser/vr/elements/ui_element_unittest.cc

@@ -89,6 +89,40 @@ TEST(UiElement, BoundsContainChildren) {
   EXPECT_FLOAT_EQ(-3.9, p.y());
 }
 
+TEST(UiElement, IgnoringAsymmetricPadding) {
+  // This test ensures that when we ignore asymmetric padding that we don't
+  // accidentally shift the location of the parent; it should stay put.
+  auto a = std::make_unique<UiElement>();
+  a->set_bounds_contain_children(true);
+
+  auto b = std::make_unique<UiElement>();
+  b->set_bounds_contain_children(true);
+  b->set_bounds_contain_padding(false);
+  b->set_padding(0.0f, 5.0f, 0.0f, 0.0f);
+
+  auto c = std::make_unique<UiElement>();
+  c->set_bounds_contain_children(true);
+  c->set_bounds_contain_padding(false);
+  c->set_padding(0.0f, 2.0f, 0.0f, 0.0f);
+
+  auto d = std::make_unique<UiElement>();
+  d->SetSize(0.5f, 0.5f);
+
+  c->AddChild(std::move(d));
+  c->DoLayOutChildren();
+  b->AddChild(std::move(c));
+  b->DoLayOutChildren();
+  a->AddChild(std::move(b));
+  a->DoLayOutChildren();
+
+  a->UpdateWorldSpaceTransformRecursive();
+
+  gfx::Point3F p;
+  a->world_space_transform().TransformPoint(&p);
+
+  EXPECT_VECTOR3DF_EQ(gfx::Point3F(), p);
+}
+
 TEST(UiElement, BoundsContainScaledChildren) {
   auto a = std::make_unique<UiElement>();
   a->SetSize(0.4, 0.3);

chrome/browser/vr/model/color_scheme.cc

@@ -152,6 +152,8 @@ void InitializeColorSchemes() {
   normal_scheme.incognito_factor = 0.0f;
   normal_scheme.fullscreen_factor = 0.0f;
 
+  normal_scheme.content_reposition_frame = 0x66FFFFFF;
+
   normal_scheme.cursor_background_center = 0x24000000;
   normal_scheme.cursor_background_edge = SK_ColorTRANSPARENT;
   normal_scheme.cursor_foreground = SK_ColorWHITE;

chrome/browser/vr/model/color_scheme.h

@@ -137,6 +137,8 @@ struct ColorScheme {
   SkColor reposition_label;
   SkColor reposition_label_background;
 
+  SkColor content_reposition_frame;
+
   SkColor cursor_background_center;
   SkColor cursor_background_edge;
   SkColor cursor_foreground;

chrome/browser/vr/renderers/gradient_quad_renderer.cc

@@ -72,13 +72,8 @@ static constexpr char const* kFragmentShader = SHADER(
   uniform mediump float u_Opacity;
   uniform vec4 u_CenterColor;
   uniform vec4 u_EdgeColor;
-  uniform vec2 u_CenterPosition;
   void main() {
-    // NB: this is on the range [0, 1] and hits its extrema at the horizontal
-    // and vertical edges of the quad, regardless of its aspect ratio. If we
-    // want to have a true circular gradient, we will need to do some extra
-    // math.
-    vec2 position = v_Position - u_CenterPosition;
+    vec2 position = v_Position;
     float edge_color_weight = clamp(2.0 * length(position), 0.0, 1.0);
     float center_color_weight = 1.0 - edge_color_weight;
     vec4 color = u_CenterColor * center_color_weight + u_EdgeColor *
@@ -122,8 +117,6 @@ GradientQuadRenderer::GradientQuadRenderer()
   center_color_handle_ = glGetUniformLocation(program_handle_, "u_CenterColor");
   edge_color_handle_ = glGetUniformLocation(program_handle_, "u_EdgeColor");
   aspect_ratio_handle_ = glGetUniformLocation(program_handle_, "u_AspectRatio");
-  center_position_handle_ =
-      glGetUniformLocation(program_handle_, "u_CenterPosition");
 }
 
 GradientQuadRenderer::~GradientQuadRenderer() = default;
@@ -131,7 +124,6 @@ GradientQuadRenderer::~GradientQuadRenderer() = default;
 void GradientQuadRenderer::Draw(const gfx::Transform& model_view_proj_matrix,
                                 SkColor edge_color,
                                 SkColor center_color,
-                                const gfx::PointF& center_position,
                                 float opacity,
                                 const gfx::SizeF& element_size,
                                 const CornerRadii& radii) {
@@ -169,9 +161,6 @@ void GradientQuadRenderer::Draw(const gfx::Transform& model_view_proj_matrix,
   glUniform1f(aspect_ratio_handle_,
               element_size.width() / element_size.height());
 
-  glUniform2f(center_position_handle_, center_position.x(),
-              center_position.y());
-
   // Pass in model view project matrix.
   glUniformMatrix4fv(model_view_proj_matrix_handle_, 1, false,
                      MatrixToGLArray(model_view_proj_matrix).data());

chrome/browser/vr/renderers/gradient_quad_renderer.h

@@ -27,7 +27,6 @@ class GradientQuadRenderer : public BaseRenderer {
   void Draw(const gfx::Transform& model_view_proj_matrix,
             SkColor edge_color,
             SkColor center_color,
-            const gfx::PointF& center_position,
             float opacity,
             const gfx::SizeF& element_size,
             const CornerRadii& radii);
@@ -44,7 +43,6 @@ class GradientQuadRenderer : public BaseRenderer {
   GLuint center_color_handle_;
   GLuint edge_color_handle_;
   GLuint aspect_ratio_handle_;
-  GLuint center_position_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(GradientQuadRenderer);
 };

chrome/browser/vr/target_property.h

@@ -23,6 +23,7 @@ enum TargetProperty {
   NORMAL_COLOR_FACTOR,
   INCOGNITO_COLOR_FACTOR,
   FULLSCREEN_COLOR_FACTOR,
+  LOCAL_OPACITY,
 
   // This must be last.
   NUM_TARGET_PROPERTIES

chrome/browser/vr/test/fake_ui_element_renderer.cc

@@ -27,7 +27,6 @@ void FakeUiElementRenderer::DrawGradientQuad(
     const gfx::Transform& view_proj_matrix,
     const SkColor edge_color,
     const SkColor center_color,
-    const gfx::PointF& center_point,
     float opacity,
     const gfx::SizeF& element_size,
     const CornerRadii& corner_radii) {

chrome/browser/vr/test/fake_ui_element_renderer.h

@@ -29,7 +29,6 @@ class FakeUiElementRenderer : public UiElementRenderer {
   void DrawGradientQuad(const gfx::Transform& view_proj_matrix,
                         const SkColor edge_color,
                         const SkColor center_color,
-                        const gfx::PointF& center_point,
                         float opacity,
                         const gfx::SizeF& element_size,
                         const CornerRadii& corner_radii) override;

chrome/browser/vr/ui_element_renderer.cc

@@ -77,15 +77,13 @@ void UiElementRenderer::DrawGradientQuad(
     const gfx::Transform& model_view_proj_matrix,
     const SkColor edge_color,
     const SkColor center_color,
-    const gfx::PointF& center_position,
     float opacity,
     const gfx::SizeF& element_size,
     const CornerRadii& radii) {
   TRACE_EVENT0("gpu", "UiElementRenderer::DrawGradientQuad");
   FlushIfNecessary(gradient_quad_renderer_.get());
   gradient_quad_renderer_->Draw(model_view_proj_matrix, edge_color,
-                                center_color, center_position, opacity,
-                                element_size, radii);
+                                center_color, opacity, element_size, radii);
 }
 
 void UiElementRenderer::DrawGradientGridQuad(

chrome/browser/vr/ui_element_renderer.h

@@ -70,7 +70,6 @@ class UiElementRenderer {
       const gfx::Transform& model_view_proj_matrix,
       const SkColor edge_color,
       const SkColor center_color,
-      const gfx::PointF& center_position,
       float opacity,
       const gfx::SizeF& element_size,
       const CornerRadii& radii);

chrome/browser/vr/ui_scene_constants.h

@@ -110,9 +110,7 @@ static constexpr float kWebVrToastDistance = 1.0f;
 static constexpr float kToastWidthDMM = 0.512f;
 static constexpr float kToastHeightDMM = 0.064f;
 static constexpr float kToastOffsetDMM = 0.004f;
-static constexpr float kFullScreenToastOffsetDMM =
-    kFullscreenVerticalOffsetDMM + kFullscreenHeightDMM / 2 + kToastHeightDMM +
-    0.004f;
+static constexpr float kFullScreenToastOffsetDMM = 0.1f;
 static constexpr float kExclusiveScreenToastXPaddingDMM = 0.017f;
 static constexpr float kExclusiveScreenToastYPaddingDMM = 0.02f;
 static constexpr float kExclusiveScreenToastCornerRadiusDMM = 0.004f;
@@ -132,6 +130,7 @@ static constexpr float kButtonDiameterDMM = 0.088f;
 static constexpr float kButtonZOffsetHoverDMM = 0.048f;
 
 static constexpr float kCloseButtonDistance = 2.4f;
+static constexpr float kCloseButtonRelativeOffset = -0.8f;
 static constexpr float kCloseButtonVerticalOffset =
     kFullscreenVerticalOffset - (kFullscreenHeight * 0.5f) - 0.35f;
 static constexpr float kCloseButtonDiameter =
@@ -299,6 +298,13 @@ static constexpr float kRepositionCursorSize = 1.2f;
 static constexpr float kMinResizerScale = 0.5f;
 static constexpr float kMaxResizerScale = 1.5f;
 
+static constexpr float kRepositionFrameTolerance = 0.3f;
+static constexpr float kRepositionFrameTopPadding = 0.25f;
+static constexpr float kRepositionFrameEdgePadding = 0.04f;
+static constexpr float kRepositionFrameMaxOpacity = 0.6f;
+static constexpr float kRepositionFrameHitPlaneTopPadding = 0.5f;
+static constexpr float kRepositionFrameTransitionDurationMs = 300;
+
 }  // namespace vr
 
 #endif  // CHROME_BROWSER_VR_UI_SCENE_CONSTANTS_H_

chrome/browser/vr/ui_scene_creator.cc

@@ -945,9 +945,6 @@ void UiSceneCreator::CreateContentQuad() {
   auto hit_plane = Create<InvisibleHitTarget>(kBackplane, kPhaseBackplanes);
   hit_plane->SetSize(kBackplaneSize, kSceneHeight);
   hit_plane->set_contributes_to_parent_bounds(false);
-  hit_plane->set_cursor_type(kCursorReposition);
-
-  hit_plane->set_event_handlers(CreateRepositioningHandlers(model_, scene_));
 
   scene_->AddUiElement(k2dBrowsingContentGroup, std::move(hit_plane));
 
@@ -1034,9 +1031,62 @@ void UiSceneCreator::CreateContentQuad() {
                         const EditedText& value) { e->UpdateInput(value); },
                      base::Unretained(main_content.get()))));
 
+  auto frame = Create<Rect>(kContentFrame, kPhaseForeground);
+  frame->set_hit_testable(true);
+  frame->set_bounds_contain_children(true);
+  frame->set_padding(kRepositionFrameEdgePadding, kRepositionFrameTopPadding,
+                     kRepositionFrameEdgePadding, kRepositionFrameEdgePadding);
+  frame->set_corner_radius(kContentCornerRadius);
+  frame->set_bounds_contain_padding(false);
+  frame->SetTransitionedProperties({LOCAL_OPACITY});
+  frame->SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kRepositionFrameTransitionDurationMs));
+  VR_BIND_COLOR(model_, frame.get(), &ColorScheme::content_reposition_frame,
+                &Rect::SetColor);
+  frame->AddBinding(std::make_unique<Binding<gfx::PointF>>(
+      VR_BIND_LAMBDA(
+          [](Model* model, UiElement* e) {
+            HitTestRequest request;
+            request.ray_origin = model->controller.laser_origin;
+            request.ray_target = model->reticle.target_point;
+            HitTestResult result;
+            e->HitTest(request, &result);
+            return gfx::PointF(
+                result.local_hit_point.x() * e->stale_size().width(),
+                result.local_hit_point.y() * e->stale_size().height());
+          },
+          base::Unretained(model_), base::Unretained(frame.get())),
+      VR_BIND_LAMBDA(
+          [](Rect* e, const gfx::PointF& value) {
+            gfx::RectF inner(e->stale_size());
+            inner.Inset(kRepositionFrameEdgePadding, kRepositionFrameTopPadding,
+                        kRepositionFrameEdgePadding,
+                        kRepositionFrameEdgePadding);
+            gfx::RectF outer(e->stale_size());
+            outer.Inset(
+                kRepositionFrameEdgePadding,
+                kRepositionFrameTopPadding - kRepositionFrameHitPlaneTopPadding,
+                kRepositionFrameEdgePadding, kRepositionFrameEdgePadding);
+            const bool is_on_frame =
+                outer.Contains(value) && !inner.Contains(value);
+            e->SetLocalOpacity(is_on_frame ? 1.0f : 0.0f);
+          },
+          base::Unretained(frame.get()))));
+
+  auto plane =
+      Create<InvisibleHitTarget>(kContentFrameHitPlane, kPhaseForeground);
+  plane->set_bounds_contain_children(true);
+  plane->set_bounds_contain_padding(false);
+  plane->set_corner_radius(kContentCornerRadius);
+  plane->set_cursor_type(kCursorReposition);
+  plane->set_padding(0, kRepositionFrameHitPlaneTopPadding, 0, 0);
+  plane->set_event_handlers(CreateRepositioningHandlers(model_, scene_));
+
   shadow->AddChild(std::move(main_content));
   resizer->AddChild(std::move(shadow));
-  scene_->AddUiElement(k2dBrowsingContentGroup, std::move(resizer));
+  plane->AddChild(std::move(resizer));
+  frame->AddChild(std::move(plane));
+  scene_->AddUiElement(k2dBrowsingContentGroup, std::move(frame));
 
   // Limit reticle distance to a sphere based on maximum content distance.
   scene_->set_background_distance(kFullscreenDistance *
@@ -1688,20 +1738,11 @@ void UiSceneCreator::CreateUrlBar() {
   scaler->set_contributes_to_parent_bounds(false);
   scene_->AddUiElement(kUrlBarPositioner, std::move(scaler));
 
-  auto backplane =
-      Create<InvisibleHitTarget>(kUrlBarBackplane, kPhaseBackplanes);
-  backplane->set_bounds_contain_children(true);
-  backplane->set_contributes_to_parent_bounds(false);
-  backplane->set_padding(kUrlBarBackplanePadding, kUrlBarBackplaneTopPadding,
-                         kUrlBarBackplanePadding, kUrlBarBackplanePadding);
-  backplane->set_event_handlers(CreateRepositioningHandlers(model_, scene_));
-  VR_BIND_VISIBILITY(backplane, !model->fullscreen_enabled());
-  scene_->AddUiElement(kUrlBarDmmRoot, std::move(backplane));
-
   auto url_bar = Create<UiElement>(kUrlBar, kPhaseNone);
   url_bar->SetRotate(1, 0, 0, kUrlBarRotationRad);
   url_bar->set_bounds_contain_children(true);
-  scene_->AddUiElement(kUrlBarBackplane, std::move(url_bar));
+  VR_BIND_VISIBILITY(url_bar, !model->fullscreen_enabled());
+  scene_->AddUiElement(kUrlBarDmmRoot, std::move(url_bar));
 
   auto layout =
       Create<LinearLayout>(kUrlBarLayout, kPhaseNone, LinearLayout::kRight);
@@ -2185,7 +2226,8 @@ void UiSceneCreator::CreateCloseButton() {
   element->set_contributes_to_parent_bounds(false);
   element->SetSize(kCloseButtonDiameter, kCloseButtonDiameter);
   element->set_hover_offset(kButtonZOffsetHoverDMM * kCloseButtonDistance);
-  element->SetTranslate(0, kCloseButtonVerticalOffset, -kCloseButtonDistance);
+  element->set_y_anchoring(BOTTOM);
+  element->SetTranslate(0, kCloseButtonRelativeOffset, -kCloseButtonDistance);
   VR_BIND_BUTTON_COLORS(model_, element.get(), &ColorScheme::button_colors,
                         &DiscButton::SetButtonColors);
 
@@ -2195,9 +2237,7 @@ void UiSceneCreator::CreateCloseButton() {
   element->AddBinding(
       VR_BIND(bool, Model, model_, model->fullscreen_enabled(), UiElement,
               element.get(),
-              view->SetTranslate(0,
-                                 value ? kCloseButtonFullscreenVerticalOffset
-                                       : kCloseButtonVerticalOffset,
+              view->SetTranslate(0, kCloseButtonRelativeOffset,
                                  value ? -kCloseButtonFullscreenDistance
                                        : -kCloseButtonDistance)));
   element->AddBinding(VR_BIND(
@@ -2404,6 +2444,7 @@ void UiSceneCreator::CreateFullscreenToast() {
   auto parent = CreateTransientParent(kExclusiveScreenToastTransientParent,
                                       kToastTimeoutSeconds, false);
   parent->set_contributes_to_parent_bounds(false);
+  parent->set_y_anchoring(TOP);
   VR_BIND_VISIBILITY(parent, model->fullscreen_enabled());
   scene_->AddUiElement(k2dBrowsingForeground, std::move(parent));
 

chrome/browser/vr/ui_unittest.cc

@@ -49,6 +49,8 @@ const std::set<UiElementName> kElementsVisibleInBrowsing = {
     kBackgroundBottom,
     kCeiling,
     kFloor,
+    kContentFrame,
+    kContentFrameHitPlane,
     kContentQuad,
     kContentQuadShadow,
     kBackplane,
@@ -457,6 +459,8 @@ TEST_F(UiTest, UiUpdatesForFullscreenChanges) {
   visible_in_fullscreen.insert(kControllerHomeButton);
   visible_in_fullscreen.insert(kLaser);
   visible_in_fullscreen.insert(kReticle);
+  visible_in_fullscreen.insert(kContentFrame);
+  visible_in_fullscreen.insert(kContentFrameHitPlane);
 
   CreateScene(kNotInCct, kNotInWebVr);