VrShell: Allow native control of UI element opacity.

chrome/browser/android/vr_shell/ui_scene_unittest.cc

 // Copyright (c) 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"
 
 #define _USE_MATH_DEFINES  // For M_PI in MSVC.
 #include <cmath>
 #include <vector>
 
@@ skipping 141 matching lines @@
   EXPECT_VEC3F_NEAR(gvr::Vec3f({0, 10, 0}), new_point);
 
   // Check with screen tilt (use 90 degrees for simplicity).
   scene.UpdateTransforms(M_PI / 2, 0);
   new_origin = MatrixVectorMul(child->transform.to_world, origin);
   new_point = MatrixVectorMul(child->transform.to_world, point);
   EXPECT_VEC3F_NEAR(gvr::Vec3f({6, 0, 10}), new_origin);
   EXPECT_VEC3F_NEAR(gvr::Vec3f({0, 0, 10}), new_point);
 }
 
+TEST(UiScene, Opacity) {
+  UiScene scene;
+  std::unique_ptr<ContentRectangle> element;
+
+  element.reset(new ContentRectangle);
+  element->id = 0;
+  element->opacity = 0.5;
+  scene.AddUiElement(element);
+
+  element.reset(new ContentRectangle);
+  element->id = 1;
+  element->parent_id = 0;
+  element->opacity = 0.5;
+  scene.AddUiElement(element);
+
+  scene.UpdateTransforms(0, 0);
+  EXPECT_EQ(scene.GetUiElementById(0)->computed_opacity, 0.5f);
+  EXPECT_EQ(scene.GetUiElementById(1)->computed_opacity, 0.25f);
+}
+
 typedef struct {
   XAnchoring x_anchoring;
   YAnchoring y_anchoring;
   float expected_x;
   float expected_y;
 } AnchoringTestCase;
 
 class AnchoringTest : public ::testing::TestWithParam<AnchoringTestCase> {};
 
 TEST_P(AnchoringTest, VerifyCorrectPosition) {
@@ skipping 38 matching lines @@
   addElement(&scene, 11);
 
   base::DictionaryValue dict;
 
   dict.SetInteger("id", 10);
   dict.SetInteger("parentId", 11);
   dict.SetBoolean("visible", false);
   dict.SetBoolean("hitTestable", false);
   dict.SetBoolean("lockToFov", true);
   dict.SetBoolean("contentQuad", true);
+  dict.SetInteger("xAnchoring", XAnchoring::XLEFT);
+  dict.SetInteger("yAnchoring", YAnchoring::YTOP);
+  dict.SetDouble("opacity", 0.357);
 
   std::unique_ptr<base::DictionaryValue> copy_rect(new base::DictionaryValue);
   copy_rect->SetInteger("x", 100);
   copy_rect->SetInteger("y", 101);
   copy_rect->SetInteger("width", 102);
   copy_rect->SetInteger("height", 103);
   dict.Set("copyRect", std::move(copy_rect));
 
   std::unique_ptr<base::DictionaryValue> size(new base::DictionaryValue);
   size->SetDouble("x", 200);
@@ skipping 12 matching lines @@
   rotation->SetDouble("z", 402);
   rotation->SetDouble("a", 403);
   dict.Set("rotation", std::move(rotation));
 
   std::unique_ptr<base::DictionaryValue> translation(new base::DictionaryValue);
   translation->SetDouble("x", 500);
   translation->SetDouble("y", 501);
   translation->SetDouble("z", 502);
   dict.Set("translation", std::move(translation));
 
-  dict.SetInteger("xAnchoring", XAnchoring::XLEFT);
-  dict.SetInteger("yAnchoring", YAnchoring::YTOP);
-
   scene.AddUiElementFromDict(dict);
   const auto *element = scene.GetUiElementById(10);
   EXPECT_NE(element, nullptr);
 
   EXPECT_EQ(element->id, 10);
   EXPECT_EQ(element->parent_id, 11);
   EXPECT_EQ(element->visible, false);
   EXPECT_EQ(element->hit_testable, false);
   EXPECT_EQ(element->lock_to_fov, true);
   EXPECT_EQ(element->content_quad, true);
+  EXPECT_EQ(element->x_anchoring, XAnchoring::XLEFT);
+  EXPECT_EQ(element->y_anchoring, YAnchoring::YTOP);
+  EXPECT_FLOAT_EQ(element->opacity, 0.357);
 
   EXPECT_EQ(element->copy_rect.x, 100);
   EXPECT_EQ(element->copy_rect.y, 101);
   EXPECT_EQ(element->copy_rect.width, 102);
   EXPECT_EQ(element->copy_rect.height, 103);
 
   EXPECT_FLOAT_EQ(element->size.x, 200);
   EXPECT_FLOAT_EQ(element->size.y, 201);
   EXPECT_FLOAT_EQ(element->size.z, 1);
 
   EXPECT_FLOAT_EQ(element->scale.x, 300);
   EXPECT_FLOAT_EQ(element->scale.y, 301);
   EXPECT_FLOAT_EQ(element->scale.z, 302);
 
   EXPECT_FLOAT_EQ(element->rotation.x, 400);
   EXPECT_FLOAT_EQ(element->rotation.y, 401);
   EXPECT_FLOAT_EQ(element->rotation.z, 402);
   EXPECT_FLOAT_EQ(element->rotation.angle, 403);
 
   EXPECT_FLOAT_EQ(element->translation.x, 500);
   EXPECT_FLOAT_EQ(element->translation.y, 501);
   EXPECT_FLOAT_EQ(element->translation.z, 502);
-
-  EXPECT_EQ(element->x_anchoring, XAnchoring::XLEFT);
-  EXPECT_EQ(element->y_anchoring, YAnchoring::YTOP);
 }
 
 TEST(UiScene, AddAnimationFromDictionary) {
   UiScene scene;
   addElement(&scene, 0);
 
   base::DictionaryValue dict;
 
   dict.SetInteger("id", 10);
   dict.SetInteger("meshId", 0);
@@ skipping 38 matching lines @@
   EXPECT_FLOAT_EQ(animation->from[0], 300);
   EXPECT_FLOAT_EQ(animation->from[1], 301);
   EXPECT_FLOAT_EQ(animation->from[2], 302);
   EXPECT_FLOAT_EQ(animation->from[3], 303);
 
   EXPECT_EQ(animation->start, 22345000);
   EXPECT_EQ(animation->duration, 54321000);
 }
 
 }  // namespace vr_shell