Make UiElement a class

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>
 
@@ skipping 587 matching lines @@
     target_element_ = plane.get();
     target_x = x;
     target_y = y;
   }
 
   // Handle input targeting on the content quad, ignoring any other elements.
   // Content is treated specially to accomodate scrolling, flings, etc.
   InputTarget input_target = InputTarget::NONE;
   int pixel_x = 0;
   int pixel_y = 0;
-  if (target_element_ != nullptr && target_element_->fill == Fill::CONTENT) {
+  if (target_element_ != nullptr && target_element_->fill() == Fill::CONTENT) {
     input_target = InputTarget::CONTENT;
     gfx::RectF pixel_rect(0, 0, content_tex_css_width_,
                           content_tex_css_height_);
     pixel_x = pixel_rect.x() + pixel_rect.width() * target_x;
     pixel_y = pixel_rect.y() + pixel_rect.height() * target_y;
   }
   SendInputToContent(input_target, pixel_x, pixel_y);
 
   // Handle input targeting on all non-content elements.
   SendInputToUiElements(target_element_);
@@ skipping 109 matching lines @@
   if (current_input_target_ != InputTarget::NONE) {
     WebInputEvent::Type type =
         new_target ? WebInputEvent::kMouseEnter : WebInputEvent::kMouseMove;
     SendGestureToContent(MakeMouseEvent(type, timestamp, pixel_x, pixel_y));
   }
 }
 
 void VrShellGl::SendInputToUiElements(UiElement* target_element) {
   if (target_element != previous_target_element_) {
     if (previous_target_element_ &&
-        previous_target_element_->fill != Fill::CONTENT) {
+        previous_target_element_->fill() != Fill::CONTENT) {
       task_runner_->PostTask(
           FROM_HERE, base::Bind(&UiElement::OnHoverLeave,
                                 base::Unretained(previous_target_element_)));
     }
-    if (target_element && target_element->fill != Fill::CONTENT) {
+    if (target_element && target_element->fill() != Fill::CONTENT) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&UiElement::OnHoverEnter,
                                         base::Unretained(target_element)));
     }
     click_target_element_ = nullptr;
   }
-  if (target_element && target_element->fill != Fill::CONTENT) {
+  if (target_element && target_element->fill() != Fill::CONTENT) {
     if (controller_->ButtonDownHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&UiElement::OnButtonDown,
                                         base::Unretained(target_element)));
       click_target_element_ = target_element;
     }
     if (controller_->ButtonUpHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       if (click_target_element_ == target_element) {
@@ skipping 239 matching lines @@
     }
   }
 }
 
 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) {
+    switch (rect->fill()) {
       case Fill::OPAQUE_GRADIENT: {
         vr_shell_renderer_->GetGradientQuadRenderer()->Draw(
-            transform, rect->edge_color, rect->center_color,
-            rect->computed_opacity);
+            transform, rect->edge_color(), rect->center_color(),
+            rect->computed_opacity());
         break;
       }
       case Fill::GRID_GRADIENT: {
         vr_shell_renderer_->GetGradientGridRenderer()->Draw(
-            transform, rect->edge_color, rect->center_color,
-            rect->gridline_count, rect->computed_opacity);
+            transform, rect->edge_color(), rect->center_color(),
+            rect->gridline_count(), rect->computed_opacity());
         break;
       }
       case Fill::CONTENT: {
         gfx::RectF copy_rect(0, 0, 1, 1);
         vr_shell_renderer_->GetExternalTexturedQuadRenderer()->Draw(
-            content_texture_id_, transform, copy_rect, rect->computed_opacity);
+            content_texture_id_, transform, copy_rect,
+            rect->computed_opacity());
         break;
       }
       case Fill::SELF: {
         rect->Render(vr_shell_renderer_.get(), transform);
         break;
       }
       default:
         break;
     }
   }
@@ skipping 15 matching lines @@
     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;
+        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 UiElement*> zOrderedElements;
   zOrderedElements.reserve(elements.size());
   for (auto distanceElementPair : zOrderedElementPairs) {
     zOrderedElements.push_back(distanceElementPair.second);
   }
@@ skipping 262 matching lines @@
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   browser_->RunVRDisplayInfoCallback(callback, &info);
 }
 
 }  // namespace vr_shell