Make base::Value::TYPE a scoped enum.

gpu/tools/compositor_model_bench/render_tree.cc

 // Copyright (c) 2012 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 "gpu/tools/compositor_model_bench/render_tree.h"
 
 #include <memory>
 #include <sstream>
 #include <vector>
 
@@ skipping 101 matching lines @@
 }
 
 void RenderNodeVisitor::EndVisitCCNode(CCNode* v) {
   this->EndVisitRenderNode(v);
 }
 
 std::unique_ptr<RenderNode> InterpretNode(const base::DictionaryValue& node);
 
 std::string ValueTypeAsString(Value::Type type) {
   switch (type) {
-    case Value::TYPE_NULL:
+    case Value::Type::NONE:
       return "NULL";
-    case Value::TYPE_BOOLEAN:
+    case Value::Type::BOOLEAN:
       return "BOOLEAN";
-    case Value::TYPE_INTEGER:
+    case Value::Type::INTEGER:
       return "INTEGER";
-    case Value::TYPE_DOUBLE:
+    case Value::Type::DOUBLE:
       return "DOUBLE";
-    case Value::TYPE_STRING:
+    case Value::Type::STRING:
       return "STRING";
-    case Value::TYPE_BINARY:
+    case Value::Type::BINARY:
       return "BINARY";
-    case Value::TYPE_DICTIONARY:
+    case Value::Type::DICTIONARY:
       return "DICTIONARY";
-    case Value::TYPE_LIST:
+    case Value::Type::LIST:
       return "LIST";
     default:
       return "(UNKNOWN TYPE)";
   }
 }
 
 // Makes sure that the key exists and has the type we expect.
 bool VerifyDictionaryEntry(const base::DictionaryValue& node,
                            const std::string& key,
                            Value::Type type) {
@@ skipping 26 matching lines @@
     LOG(ERROR) << (listName ? listName : "List") << "element " << idx
                << " did not have the expected type (expected "
                << ValueTypeAsString(type) << ")\n";
     return false;
   }
 
   return true;
 }
 
 bool InterpretCommonContents(const base::DictionaryValue& node, RenderNode* c) {
-  if (!VerifyDictionaryEntry(node, "layerID", Value::TYPE_INTEGER) ||
-      !VerifyDictionaryEntry(node, "width", Value::TYPE_INTEGER) ||
-      !VerifyDictionaryEntry(node, "height", Value::TYPE_INTEGER) ||
-      !VerifyDictionaryEntry(node, "drawsContent", Value::TYPE_BOOLEAN) ||
-      !VerifyDictionaryEntry(node, "targetSurfaceID", Value::TYPE_INTEGER) ||
-      !VerifyDictionaryEntry(node, "transform", Value::TYPE_LIST)) {
+  if (!VerifyDictionaryEntry(node, "layerID", Value::Type::INTEGER) ||
+      !VerifyDictionaryEntry(node, "width", Value::Type::INTEGER) ||
+      !VerifyDictionaryEntry(node, "height", Value::Type::INTEGER) ||
+      !VerifyDictionaryEntry(node, "drawsContent", Value::Type::BOOLEAN) ||
+      !VerifyDictionaryEntry(node, "targetSurfaceID", Value::Type::INTEGER) ||
+      !VerifyDictionaryEntry(node, "transform", Value::Type::LIST)) {
     return false;
   }
 
   int layerID;
   node.GetInteger("layerID", &layerID);
   c->set_layerID(layerID);
   int width;
   node.GetInteger("width", &width);
   c->set_width(width);
   int height;
   node.GetInteger("height", &height);
   c->set_height(height);
   bool drawsContent;
   node.GetBoolean("drawsContent", &drawsContent);
   c->set_drawsContent(drawsContent);
   int targetSurface;
   node.GetInteger("targetSurfaceID", &targetSurface);
   c->set_targetSurface(targetSurface);
 
   const base::ListValue* transform;
   node.GetList("transform", &transform);
   if (transform->GetSize() != 16) {
     LOG(ERROR) << "4x4 transform matrix did not have 16 elements";
     return false;
   }
   float transform_mat[16];
   for (int i = 0; i < 16; ++i) {
-    if (!VerifyListEntry(*transform, i, Value::TYPE_DOUBLE, "Transform"))
+    if (!VerifyListEntry(*transform, i, Value::Type::DOUBLE, "Transform"))
       return false;
     double el;
     transform->GetDouble(i, &el);
     transform_mat[i] = el;
   }
   c->set_transform(transform_mat);
 
   if (!node.HasKey("tiles"))
     return true;
 
-  if (!VerifyDictionaryEntry(node, "tiles", Value::TYPE_DICTIONARY))
+  if (!VerifyDictionaryEntry(node, "tiles", Value::Type::DICTIONARY))
     return false;
   const base::DictionaryValue* tiles_dict;
   node.GetDictionary("tiles", &tiles_dict);
-  if (!VerifyDictionaryEntry(*tiles_dict, "dim", Value::TYPE_LIST))
+  if (!VerifyDictionaryEntry(*tiles_dict, "dim", Value::Type::LIST))
     return false;
   const base::ListValue* dim;
   tiles_dict->GetList("dim", &dim);
-  if (!VerifyListEntry(*dim, 0, Value::TYPE_INTEGER, "Tile dimension") ||
-      !VerifyListEntry(*dim, 1, Value::TYPE_INTEGER, "Tile dimension")) {
+  if (!VerifyListEntry(*dim, 0, Value::Type::INTEGER, "Tile dimension") ||
+      !VerifyListEntry(*dim, 1, Value::Type::INTEGER, "Tile dimension")) {
     return false;
   }
   int tile_width;
   dim->GetInteger(0, &tile_width);
   c->set_tile_width(tile_width);
   int tile_height;
   dim->GetInteger(1, &tile_height);
   c->set_tile_height(tile_height);
 
-  if (!VerifyDictionaryEntry(*tiles_dict, "info", Value::TYPE_LIST))
+  if (!VerifyDictionaryEntry(*tiles_dict, "info", Value::Type::LIST))
     return false;
   const base::ListValue* tiles;
   tiles_dict->GetList("info", &tiles);
   for (unsigned int i = 0; i < tiles->GetSize(); ++i) {
-    if (!VerifyListEntry(*tiles, i, Value::TYPE_DICTIONARY, "Tile info"))
+    if (!VerifyListEntry(*tiles, i, Value::Type::DICTIONARY, "Tile info"))
       return false;
     const base::DictionaryValue* tdict;
     tiles->GetDictionary(i, &tdict);
 
-    if (!VerifyDictionaryEntry(*tdict, "x", Value::TYPE_INTEGER) ||
-        !VerifyDictionaryEntry(*tdict, "y", Value::TYPE_INTEGER)) {
+    if (!VerifyDictionaryEntry(*tdict, "x", Value::Type::INTEGER) ||
+        !VerifyDictionaryEntry(*tdict, "y", Value::Type::INTEGER)) {
       return false;
     }
     Tile t;
     tdict->GetInteger("x", &t.x);
     tdict->GetInteger("y", &t.y);
     if (tdict->HasKey("texID")) {
-      if (!VerifyDictionaryEntry(*tdict, "texID", Value::TYPE_INTEGER))
+      if (!VerifyDictionaryEntry(*tdict, "texID", Value::Type::INTEGER))
         return false;
       tdict->GetInteger("texID", &t.texID);
     } else {
       t.texID = -1;
     }
     c->add_tile(t);
   }
   return true;
 }
 
 bool InterpretCCData(const base::DictionaryValue& node, CCNode* c) {
-  if (!VerifyDictionaryEntry(node, "vertex_shader", Value::TYPE_STRING) ||
-      !VerifyDictionaryEntry(node, "fragment_shader", Value::TYPE_STRING) ||
-      !VerifyDictionaryEntry(node, "textures", Value::TYPE_LIST)) {
+  if (!VerifyDictionaryEntry(node, "vertex_shader", Value::Type::STRING) ||
+      !VerifyDictionaryEntry(node, "fragment_shader", Value::Type::STRING) ||
+      !VerifyDictionaryEntry(node, "textures", Value::Type::LIST)) {
     return false;
   }
   std::string vertex_shader_name, fragment_shader_name;
   node.GetString("vertex_shader", &vertex_shader_name);
   node.GetString("fragment_shader", &fragment_shader_name);
 
   c->set_vertex_shader(ShaderIDFromString(vertex_shader_name));
   c->set_fragment_shader(ShaderIDFromString(fragment_shader_name));
   const base::ListValue* textures;
   node.GetList("textures", &textures);
   for (unsigned int i = 0; i < textures->GetSize(); ++i) {
-    if (!VerifyListEntry(*textures, i, Value::TYPE_DICTIONARY, "Tex list"))
+    if (!VerifyListEntry(*textures, i, Value::Type::DICTIONARY, "Tex list"))
       return false;
     const base::DictionaryValue* tex;
     textures->GetDictionary(i, &tex);
 
-    if (!VerifyDictionaryEntry(*tex, "texID", Value::TYPE_INTEGER) ||
-        !VerifyDictionaryEntry(*tex, "height", Value::TYPE_INTEGER) ||
-        !VerifyDictionaryEntry(*tex, "width", Value::TYPE_INTEGER) ||
-        !VerifyDictionaryEntry(*tex, "format", Value::TYPE_STRING)) {
+    if (!VerifyDictionaryEntry(*tex, "texID", Value::Type::INTEGER) ||
+        !VerifyDictionaryEntry(*tex, "height", Value::Type::INTEGER) ||
+        !VerifyDictionaryEntry(*tex, "width", Value::Type::INTEGER) ||
+        !VerifyDictionaryEntry(*tex, "format", Value::Type::STRING)) {
       return false;
     }
     Texture t;
     tex->GetInteger("texID", &t.texID);
     tex->GetInteger("height", &t.height);
     tex->GetInteger("width", &t.width);
 
     std::string formatName;
     tex->GetString("format", &formatName);
     t.format = TextureFormatFromString(formatName);
@@ skipping 22 matching lines @@
 
   return true;
 }
 
 std::unique_ptr<RenderNode> InterpretContentLayer(
     const base::DictionaryValue& node) {
   auto n = base::MakeUnique<ContentLayerNode>();
   if (!InterpretCommonContents(node, n.get()))
     return nullptr;
 
-  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING) ||
-      !VerifyDictionaryEntry(node, "skipsDraw", Value::TYPE_BOOLEAN) ||
-      !VerifyDictionaryEntry(node, "children", Value::TYPE_LIST)) {
+  if (!VerifyDictionaryEntry(node, "type", Value::Type::STRING) ||
+      !VerifyDictionaryEntry(node, "skipsDraw", Value::Type::BOOLEAN) ||
+      !VerifyDictionaryEntry(node, "children", Value::Type::LIST)) {
     return nullptr;
   }
 
   std::string type;
   node.GetString("type", &type);
   DCHECK_EQ(type, "ContentLayer");
   bool skipsDraw;
   node.GetBoolean("skipsDraw", &skipsDraw);
   n->set_skipsDraw(skipsDraw);
 
@@ skipping 10 matching lines @@
 
   return n;
 }
 
 std::unique_ptr<RenderNode> InterpretCanvasLayer(
     const base::DictionaryValue& node) {
   auto n = base::MakeUnique<CCNode>();
   if (!InterpretCommonContents(node, n.get()))
     return nullptr;
 
-  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING))
+  if (!VerifyDictionaryEntry(node, "type", Value::Type::STRING))
     return nullptr;
 
   std::string type;
   node.GetString("type", &type);
   assert(type == "CanvasLayer");
 
   if (!InterpretCCData(node, n.get()))
     return nullptr;
 
   return n;
 }
 
 std::unique_ptr<RenderNode> InterpretVideoLayer(
     const base::DictionaryValue& node) {
   auto n = base::MakeUnique<CCNode>();
   if (!InterpretCommonContents(node, n.get()))
     return nullptr;
 
-  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING))
+  if (!VerifyDictionaryEntry(node, "type", Value::Type::STRING))
     return nullptr;
 
   std::string type;
   node.GetString("type", &type);
   assert(type == "VideoLayer");
 
   if (!InterpretCCData(node, n.get()))
     return nullptr;
 
   return n;
 }
 
 std::unique_ptr<RenderNode> InterpretImageLayer(
     const base::DictionaryValue& node) {
   auto n = base::MakeUnique<CCNode>();
   if (!InterpretCommonContents(node, n.get()))
     return nullptr;
 
-  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING))
+  if (!VerifyDictionaryEntry(node, "type", Value::Type::STRING))
     return nullptr;
 
   std::string type;
   node.GetString("type", &type);
   assert(type == "ImageLayer");
 
   if (!InterpretCCData(node, n.get()))
     return nullptr;
 
   return n;
 }
 
 std::unique_ptr<RenderNode> InterpretNode(const base::DictionaryValue& node) {
-  if (!VerifyDictionaryEntry(node, "type", Value::TYPE_STRING))
+  if (!VerifyDictionaryEntry(node, "type", Value::Type::STRING))
     return nullptr;
 
   std::string type;
   node.GetString("type", &type);
   if (type == "ContentLayer")
     return InterpretContentLayer(node);
   if (type == "CanvasLayer")
     return InterpretCanvasLayer(node);
   if (type == "VideoLayer")
     return InterpretVideoLayer(node);
@@ skipping 29 matching lines @@
     } else {
       LOG(ERROR) << path.LossyDisplayName()
                  << " doesn not encode a JSON dictionary.";
     }
     return nullptr;
   }
 
   return InterpretContentLayer(*root);
 }