VR: Rename ContentRectangle to UiElement

chrome/browser/android/vr_shell/vr_shell_gl.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_gl.h"
 
 #include <chrono>
 #include <limits>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/vr_shell/mailbox_to_surface_bridge.h"
-#include "chrome/browser/android/vr_shell/ui_elements.h"
+#include "chrome/browser/android/vr_shell/ui_element.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "device/vr/android/gvr/gvr_delegate.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_gamepad_data_provider.h"
 #include "device/vr/vr_math.h"
@@ skipping 864 matching lines @@
     // Non-WebVR mode, enable depth testing and clear the primary buffers.
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
     glDepthMask(GL_TRUE);
 
     const vr::Colorf& backgroundColor = scene_->GetBackgroundColor();
     glClearColor(backgroundColor.r, backgroundColor.g, backgroundColor.b,
                  backgroundColor.a);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
-  std::vector<const ContentRectangle*> elements = scene_->GetWorldElements();
+  std::vector<const UiElement*> elements = scene_->GetWorldElements();
   DrawUiView(head_pose, elements, render_size_primary_,
              kViewportListPrimaryOffset, !ShouldDrawWebVr());
 }
 
 void VrShellGl::DrawHeadLockedElements() {
   TRACE_EVENT0("gpu", "VrShellGl::DrawHeadLockedElements");
-  std::vector<const ContentRectangle*> elements =
-      scene_->GetHeadLockedElements();
+  std::vector<const UiElement*> elements = scene_->GetHeadLockedElements();
 
   // Add head-locked viewports. The list gets reset to just
   // the recommended viewports (for the primary buffer) each frame.
   buffer_viewport_list_->SetBufferViewport(
       kViewportListHeadlockedOffset + GVR_LEFT_EYE, *headlocked_left_viewport_);
   buffer_viewport_list_->SetBufferViewport(
       kViewportListHeadlockedOffset + GVR_RIGHT_EYE,
       *headlocked_right_viewport_);
 
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   vr::Mat4f identity_matrix;
   vr::SetIdentityM(&identity_matrix);
   DrawUiView(identity_matrix, elements, render_size_headlocked_,
              kViewportListHeadlockedOffset, false);
 }
 
 void VrShellGl::DrawUiView(const vr::Mat4f& head_pose,
-                           const std::vector<const ContentRectangle*>& elements,
+                           const std::vector<const UiElement*>& elements,
                            const gfx::Size& render_size,
                            int viewport_offset,
                            bool draw_cursor) {
   TRACE_EVENT0("gpu", "VrShellGl::DrawUiView");
 
   auto elementsInDrawOrder = GetElementsInDrawOrder(head_pose, elements);
 
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(eye + viewport_offset,
                                              buffer_viewport_.get());
@@ skipping 19 matching lines @@
     vr::MatrixMul(perspective_matrix, eye_view_matrix, &render_matrix);
 
     DrawElements(render_matrix, elementsInDrawOrder);
     if (draw_cursor) {
       DrawCursor(render_matrix);
       DrawController(render_matrix);
     }
   }
 }
 
-void VrShellGl::DrawElements(
-    const vr::Mat4f& view_proj_matrix,
-    const std::vector<const ContentRectangle*>& elements) {
+void VrShellGl::DrawElements(const vr::Mat4f& view_proj_matrix,
+                             const std::vector<const UiElement*>& elements) {
   for (const auto* rect : elements) {
     vr::Mat4f transform;
     vr::MatrixMul(view_proj_matrix, rect->TransformMatrix(), &transform);
 
     switch (rect->fill) {
       case Fill::SPRITE: {
         gfx::RectF copy_rect(
             static_cast<float>(rect->copy_rect.x()) / ui_tex_css_width_,
             static_cast<float>(rect->copy_rect.y()) / ui_tex_css_height_,
             static_cast<float>(rect->copy_rect.width()) / ui_tex_css_width_,
@@ skipping 25 matching lines @@
         break;
       }
       default:
         break;
     }
   }
 
   vr_shell_renderer_->GetTexturedQuadRenderer()->Flush();
 }
 
-std::vector<const ContentRectangle*> VrShellGl::GetElementsInDrawOrder(
+std::vector<const UiElement*> VrShellGl::GetElementsInDrawOrder(
     const vr::Mat4f& view_matrix,
-    const std::vector<const ContentRectangle*>& elements) {
-  typedef std::pair<float, const ContentRectangle*> DistanceElementPair;
+    const std::vector<const UiElement*>& elements) {
+  typedef std::pair<float, const UiElement*> DistanceElementPair;
   std::vector<DistanceElementPair> zOrderedElementPairs;
   zOrderedElementPairs.reserve(elements.size());
 
   for (const auto* element : elements) {
     // Distance is the abs(z) value in view space.
     gfx::Vector3dF element_position =
         vr::GetTranslation(element->TransformMatrix());
 
     float distance =
         std::fabs(vr::MatrixVectorMul(view_matrix, element_position).z());
     zOrderedElementPairs.push_back(std::make_pair(distance, element));
   }
 
   // Sort elements primarily based on their draw phase (lower draw phase first)
   // and secondarily based on their distance (larger distance first).
   std::sort(
       zOrderedElementPairs.begin(), zOrderedElementPairs.end(),
       [](const DistanceElementPair& first, const DistanceElementPair& second) {
         if (first.second->draw_phase != second.second->draw_phase) {
           return first.second->draw_phase < second.second->draw_phase;
         } else {
           return first.first > second.first;
         }
       });
 
-  std::vector<const ContentRectangle*> zOrderedElements;
+  std::vector<const UiElement*> zOrderedElements;
   zOrderedElements.reserve(elements.size());
   for (auto distanceElementPair : zOrderedElementPairs) {
     zOrderedElements.push_back(distanceElementPair.second);
   }
   return zOrderedElements;
 }
 
 void VrShellGl::DrawCursor(const vr::Mat4f& render_matrix) {
   vr::Mat4f mat;
   vr::SetIdentityM(&mat);
@@ skipping 277 matching lines @@
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell