PROTOTYPE: Generic custom CSS property parsing

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/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"
 
 namespace vr_shell {
 
 namespace {
 
+bool ParseNumber(const base::DictionaryValue& dict,
+                 const std::string& key,
+                 float* output) {
+  double number;
+  if (!dict.GetDouble(key, &number)) {
+    return false;
+  }
+  *output = number;
+  return true;
+}
+
 bool ParseRecti(const base::DictionaryValue& dict,
                 const std::string& key,
                 Recti* output) {
   const base::DictionaryValue* item_dict;
   if (dict.GetDictionary(key, &item_dict)) {
     CHECK(item_dict->GetInteger("x", &output->x));
     CHECK(item_dict->GetInteger("y", &output->y));
     CHECK(item_dict->GetInteger("width", &output->width));
     CHECK(item_dict->GetInteger("height", &output->height));
     return true;
   } else {
     return false;
   }
 }
 
+#if 0
 bool Parse2DVec3f(const base::DictionaryValue& dict,
                   const std::string& key,
                   gvr::Vec3f* output) {
   const base::DictionaryValue* item_dict;
   if (dict.GetDictionary(key, &item_dict)) {
     double value;
     CHECK(item_dict->GetDouble("x", &value));
     output->x = value;
     CHECK(item_dict->GetDouble("y", &value));
     output->y = value;
@@ skipping 14 matching lines @@
     output->x = value;
     CHECK(item_dict->GetDouble("y", &value));
     output->y = value;
     CHECK(item_dict->GetDouble("z", &value));
     output->z = value;
     return true;
   } else {
     return false;
   }
 }
+#endif
 
 bool ParseColorf(const base::DictionaryValue& dict,
                  const std::string& key,
                  Colorf* output) {
   const base::DictionaryValue* item_dict;
   if (dict.GetDictionary(key, &item_dict)) {
     double value;
     CHECK(item_dict->GetDouble("r", &value));
     output->r = value;
     CHECK(item_dict->GetDouble("g", &value));
     output->g = value;
     CHECK(item_dict->GetDouble("b", &value));
     output->b = value;
     CHECK(item_dict->GetDouble("a", &value));
     output->a = value;
     return true;
   } else {
     return false;
   }
 }
 
+#if 0
 bool ParseRotationAxisAngle(const base::DictionaryValue& dict,
                             const std::string& key,
                             RotationAxisAngle* output) {
   const base::DictionaryValue* item_dict;
   if (dict.GetDictionary(key, &item_dict)) {
     double value;
     CHECK(item_dict->GetDouble("x", &value));
     output->x = value;
     CHECK(item_dict->GetDouble("y", &value));
     output->y = value;
     CHECK(item_dict->GetDouble("z", &value));
     output->z = value;
     CHECK(item_dict->GetDouble("a", &value));
     output->angle = value;
     return true;
   } else {
     return false;
   }
 }
+#endif
 
 void ParseFloats(const base::DictionaryValue& dict,
                  const std::vector<std::string>& keys,
                  std::vector<float>* vec) {
   for (const auto& key : keys) {
     double value;
     CHECK(dict.GetDouble(key, &value)) << "parsing tag " << key;
     vec->push_back(value);
   }
 }
@@ skipping 304 matching lines @@
     CHECK(parent != nullptr);
     ApplyAnchoring(*parent, element.x_anchoring, element.y_anchoring,
                    transform);
     ApplyRecursiveTransforms(*parent, transform, opacity);
   }
 }
 
 void UiScene::ApplyDictToElement(const base::DictionaryValue& dict,
                                  ContentRectangle *element) {
   int parent_id;
+  //const base::DictionaryValue* item_dict;
+
   if (dict.GetInteger("parentId", &parent_id)) {
     CHECK_GE(parent_id, 0);
     CHECK_NE(GetUiElementById(parent_id), nullptr);
     element->parent_id = parent_id;
   }
 
   dict.GetBoolean("visible", &element->visible);
   dict.GetBoolean("hitTestable", &element->hit_testable);
   dict.GetBoolean("lockToFov", &element->lock_to_fov);
-  Parse2DVec3f(dict, "size", &element->size);
-  ParseVec3f(dict, "scale", &element->scale);
-  ParseRotationAxisAngle(dict, "rotation", &element->rotation);
-  ParseVec3f(dict, "translation", &element->translation);
-  double opacity;
-  if (dict.GetDouble("opacity", &opacity)) {
-    element->opacity = opacity;
-  }
 
+  ParseNumber(dict, "sizeX", &element->size.x);

[cjgrant, 2017/02/15 16:34:27]

Independent of CSS custom properties, I'd like to clean up and submit this
change separately. I think it makes sense to allow tweaking of individual
properties.

[tiborg, 2017/02/15 18:36:11]

+1, this is a good idea.

[cjgrant, 2017/03/03 15:11:07]

For the record, this change landed in ToT, and is rebased out of  this CL.

+  ParseNumber(dict, "sizeY", &element->size.y);
+  ParseNumber(dict, "scaleX", &element->scale.x);
+  ParseNumber(dict, "scaleY", &element->scale.y);
+  ParseNumber(dict, "scaleZ", &element->scale.z);
+  ParseNumber(dict, "rotationX", &element->rotation.x);
+  ParseNumber(dict, "rotationY", &element->rotation.y);
+  ParseNumber(dict, "rotationZ", &element->rotation.z);
+  ParseNumber(dict, "rotationAngle", &element->rotation.angle);
+  ParseNumber(dict, "translationX", &element->translation.x);
+  ParseNumber(dict, "translationY", &element->translation.y);
+  ParseNumber(dict, "translationZ", &element->translation.z);
+
+  ParseNumber(dict, "opacity", &element->opacity);
   if (dict.GetInteger("xAnchoring",
                       reinterpret_cast<int*>(&element->x_anchoring))) {
     CHECK_GE(element->parent_id, 0);
   }
   if (dict.GetInteger("yAnchoring",
                       reinterpret_cast<int*>(&element->y_anchoring))) {
     CHECK_GE(element->parent_id, 0);
   }
 
   // Parse the element fill.
@@ skipping 23 matching lines @@
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell