VrShell background implemented in JS.

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 "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"
@@ skipping 33 matching lines @@
     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;
   }
 }
 
+void 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;
+  }
+}
+
 void 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));
@@ skipping 134 matching lines @@
   int id;
   CHECK(dict.GetInteger("id", &id));
   ContentRectangle* 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)->content_quad) {
+      if ((*it)->fill == Fill::CONTENT) {
         content_element_ = nullptr;
       }
       ui_elements_.erase(it);
       return;
     }
   }
 }
 
 void UiScene::AddAnimation(int element_id,
                            std::unique_ptr<Animation>& animation) {
@@ skipping 161 matching lines @@
   int parent_id;
   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);
-  ParseRecti(dict, "copyRect", &element->copy_rect);
   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;
   }
 
-  if (dict.GetBoolean("contentQuad", &element->content_quad)) {
-    if (element->content_quad) {
-      CHECK_EQ(content_element_, nullptr);
-      content_element_ = element;
-    } else {
-      if (content_element_ == element) {
-        content_element_ = nullptr;
-      }
-    }
-  }
-
   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.
+  if (dict.GetInteger("fillType", reinterpret_cast<int*>(&element->fill))) {
+    // If the previous content element has a new filling now make sure this is
+    // tracked correctly.
+    if (content_element_ == element && element->fill != Fill::CONTENT) {
+      content_element_ = nullptr;
+    }
+
+    switch (element->fill) {
+      case Fill::SPRITE:
+        ParseRecti(dict, "copyRect", &element->copy_rect);
+        break;
+      case Fill::OPAQUE_GRADIENT:
+        ParseColorf(dict, "edgeColor", &element->edge_color);
+        ParseColorf(dict, "centerColor", &element->center_color);
+        break;
+      case Fill::GRID_GRADIENT:
+        ParseColorf(dict, "edgeColor", &element->edge_color);
+        ParseColorf(dict, "centerColor", &element->center_color);
+        int value;
+        dict.GetInteger("tileNumber", &value);

[cjgrant, 2017/02/02 14:48:25]

- This code is setting tile_number to a random value if not in the dictionary -
it should be CHECK()ing.
- Why not read directly into element->tile_number?  If it's because of the
unsigned type mismatch, the lets just make tile_number an int.

[tiborg1, 2017/02/02 16:52:27]

Good call! I changed tile number to unsigned since there was another error
because of unsigned-signed integer comparison. Since tile number / gridline
count cannot reasonably be negative, I thought unsigned would be the better
choice here. But it makes the code handling more complicated. So, it's signed
again with a check so that it is never negative.

[cjgrant, 2017/02/03 15:58:29]

We should also check that the read from the dictionary got a value (so keep the
existing check, and add a new one on the previous line).

+        element->tile_number = value;
+        break;
+      case Fill::CONTENT:
+        CHECK_EQ(content_element_, nullptr);
+        content_element_ = element;
+        break;
+      default:
+        element->fill = Fill::NONE;
+        break;
+    }
+  }
 }
 
 }  // namespace vr_shell