VR: Rename ContentRectangle to UiElement

chrome/browser/android/vr_shell/ui_scene.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/ui_scene.h"
 
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/animation.h"
 #include "chrome/browser/android/vr_shell/easing.h"
-#include "chrome/browser/android/vr_shell/ui_elements.h"
+#include "chrome/browser/android/vr_shell/ui_element.h"
 #include "device/vr/vr_math.h"
 
 namespace vr_shell {
 
 namespace {
 
 // Parse an integer to an int or enum value.
 template <typename T>
 bool ParseInt(const base::DictionaryValue& dict,
               const std::string& key,
@@ skipping 109 matching lines @@
     case easing::EasingType::EASEINOUT: {
       double pow;
       CHECK(dict.GetDouble("pow", &pow));
       result = base::MakeUnique<easing::EaseInOut>(pow);
       break;
     }
   }
   return result;
 }
 
-void ApplyAnchoring(const ContentRectangle& parent,
+void ApplyAnchoring(const UiElement& parent,
                     XAnchoring x_anchoring,
                     YAnchoring y_anchoring,
                     Transform* transform) {
   // To anchor a child, use the parent's size to find its edge.
   float x_offset;
   switch (x_anchoring) {
     case XLEFT:
       x_offset = -0.5f * parent.size.x();
       break;
     case XRIGHT:
@@ skipping 13 matching lines @@
       break;
     case YNONE:
       y_offset = 0.0f;
       break;
   }
   transform->Translate(gfx::Vector3dF(x_offset, y_offset, 0));
 }
 
 }  // namespace
 
-void UiScene::AddUiElement(std::unique_ptr<ContentRectangle> element) {
+void UiScene::AddUiElement(std::unique_ptr<UiElement> element) {
   CHECK_GE(element->id, 0);
   CHECK_EQ(GetUiElementById(element->id), nullptr);
   if (element->parent_id >= 0) {
     CHECK_NE(GetUiElementById(element->parent_id), nullptr);
   } else {
     CHECK_EQ(element->x_anchoring, XAnchoring::XNONE);
     CHECK_EQ(element->y_anchoring, YAnchoring::YNONE);
   }
   ui_elements_.push_back(std::move(element));
 }
 
 void UiScene::AddUiElementFromDict(const base::DictionaryValue& dict) {
   int id;
   CHECK(ParseInt(dict, "id", &id));
   CHECK_EQ(GetUiElementById(id), nullptr);
 
-  auto element = base::MakeUnique<ContentRectangle>();
+  auto element = base::MakeUnique<UiElement>();
   element->id = id;
 
   ApplyDictToElement(dict, element.get());
   ui_elements_.push_back(std::move(element));
 }
 
 void UiScene::UpdateUiElementFromDict(const base::DictionaryValue& dict) {
   int id;
   CHECK(ParseInt(dict, "id", &id));
-  ContentRectangle* element = GetUiElementById(id);
+  UiElement* element = GetUiElementById(id);
   CHECK_NE(element, nullptr);
   ApplyDictToElement(dict, element);
 }
 
 void UiScene::RemoveUiElement(int element_id) {
   for (auto it = ui_elements_.begin(); it != ui_elements_.end(); ++it) {
     if ((*it)->id == element_id) {
       if ((*it)->fill == Fill::CONTENT) {
         content_element_ = nullptr;
       }
       ui_elements_.erase(it);
       return;
     }
   }
 }
 
 void UiScene::AddAnimation(int element_id,
                            std::unique_ptr<Animation> animation) {
-  ContentRectangle* element = GetUiElementById(element_id);
+  UiElement* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   for (auto& existing_animation : element->animations) {
     CHECK_NE(existing_animation->id, animation->id);
   }
   element->animations.emplace_back(std::move(animation));
 }
 
 void UiScene::AddAnimationFromDict(const base::DictionaryValue& dict,
                                    const base::TimeTicks& current_time) {
   int animation_id;
@@ skipping 24 matching lines @@
   // start from the element's current location.
   dict.GetDictionary("from", &from_dict);
   if (from_dict != nullptr) {
     ParseEndpointToFloats(property, *from_dict, &from);
   }
 
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(start_time_ms);
   base::TimeTicks start = current_time + delay;
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(duration_ms);
 
-  ContentRectangle* element = GetUiElementById(element_id);
+  UiElement* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   element->animations.emplace_back(base::MakeUnique<Animation>(
       animation_id, static_cast<Animation::Property>(property),
       std::move(easing), from, to, start, duration));
 }
 
 void UiScene::RemoveAnimation(int element_id, int animation_id) {
-  ContentRectangle* element = GetUiElementById(element_id);
+  UiElement* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   auto& animations = element->animations;
   for (auto it = animations.begin(); it != animations.end(); ++it) {
     const Animation& existing_animation = **it;
     if (existing_animation.id == animation_id) {
       animations.erase(it);
       return;
     }
   }
 }
@@ skipping 45 matching lines @@
   for (auto& element : ui_elements_) {
     // Process all animations before calculating object transforms.
     element->Animate(time);
     element->dirty = true;
   }
   for (auto& element : ui_elements_) {
     ApplyRecursiveTransforms(element.get());
   }
 }
 
-ContentRectangle* UiScene::GetUiElementById(int element_id) {
+UiElement* UiScene::GetUiElementById(int element_id) {
   for (auto& element : ui_elements_) {
     if (element->id == element_id) {
       return element.get();
     }
   }
   return nullptr;
 }
 
-std::vector<const ContentRectangle*> UiScene::GetWorldElements() const {
-  std::vector<const ContentRectangle*> elements;
+std::vector<const UiElement*> UiScene::GetWorldElements() const {
+  std::vector<const UiElement*> elements;
   for (const auto& element : ui_elements_) {
     if (element->IsVisible() && !element->lock_to_fov) {
       elements.push_back(element.get());
     }
   }
   return elements;
 }
 
-std::vector<const ContentRectangle*> UiScene::GetHeadLockedElements() const {
-  std::vector<const ContentRectangle*> elements;
+std::vector<const UiElement*> UiScene::GetHeadLockedElements() const {
+  std::vector<const UiElement*> elements;
   for (const auto& element : ui_elements_) {
     if (element->IsVisible() && element->lock_to_fov) {
       elements.push_back(element.get());
     }
   }
   return elements;
 }
 
 bool UiScene::HasVisibleHeadLockedElements() const {
   return !GetHeadLockedElements().empty();
 }
 
 const vr::Colorf& UiScene::GetBackgroundColor() const {
   return background_color_;
 }
 
 float UiScene::GetBackgroundDistance() const {
   return background_distance_;
 }
 
 bool UiScene::GetWebVrRenderingEnabled() const {
   return webvr_rendering_enabled_;
 }
 
-const std::vector<std::unique_ptr<ContentRectangle>>& UiScene::GetUiElements()
-    const {
+const std::vector<std::unique_ptr<UiElement>>& UiScene::GetUiElements() const {
   return ui_elements_;
 }
 
 UiScene::UiScene() = default;
 
 UiScene::~UiScene() = default;
 
-void UiScene::ApplyRecursiveTransforms(ContentRectangle* element) {
+void UiScene::ApplyRecursiveTransforms(UiElement* element) {
   if (!element->dirty)
     return;
 
-  ContentRectangle* parent = nullptr;
+  UiElement* parent = nullptr;
   if (element->parent_id >= 0) {
     parent = GetUiElementById(element->parent_id);
     CHECK(parent != nullptr);
   }
 
   Transform* transform = element->mutable_transform();
   transform->MakeIdentity();
   transform->Scale(element->size);
   element->computed_opacity = element->opacity;
   element->computed_lock_to_fov = element->lock_to_fov;
@@ skipping 15 matching lines @@
     element->computed_opacity *= parent->opacity;
     element->computed_lock_to_fov = parent->lock_to_fov;
   }
 
   vr::MatrixMul(inheritable->to_world, transform->to_world,
                 &transform->to_world);
   element->dirty = false;
 }
 
 void UiScene::ApplyDictToElement(const base::DictionaryValue& dict,
-                                 ContentRectangle* element) {
+                                 UiElement* element) {
   int parent_id;
 
   if (ParseInt(dict, "parentId", &parent_id)) {
     CHECK_GE(parent_id, 0);
     CHECK_NE(GetUiElementById(parent_id), nullptr);
     element->parent_id = parent_id;
   }
 
   dict.GetString("name", &element->name);
   dict.GetBoolean("visible", &element->visible);
@@ skipping 67 matching lines @@
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell