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

content/child/v8_value_converter_impl_unittest.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 "content/child/v8_value_converter_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 113 matching lines @@
     }
     return temp->Value();
   }
 
   bool IsNull(base::DictionaryValue* value, const std::string& key) {
     base::Value* child = NULL;
     if (!value->Get(key, &child)) {
       ADD_FAILURE();
       return false;
     }
-    return child->GetType() == base::Value::TYPE_NULL;
+    return child->GetType() == base::Value::Type::NONE;
   }
 
   bool IsNull(v8::Local<v8::Object> value, const std::string& key) {
     v8::Local<v8::Value> child =
         value->Get(v8::String::NewFromUtf8(isolate_, key.c_str()));
     if (child.IsEmpty()) {
       ADD_FAILURE();
       return false;
     }
     return child->IsNull();
   }
 
   bool IsNull(base::ListValue* value, uint32_t index) {
     base::Value* child = NULL;
     if (!value->Get(static_cast<size_t>(index), &child)) {
       ADD_FAILURE();
       return false;
     }
-    return child->GetType() == base::Value::TYPE_NULL;
+    return child->GetType() == base::Value::Type::NONE;
   }
 
   bool IsNull(v8::Local<v8::Array> value, uint32_t index) {
     v8::Local<v8::Value> child = value->Get(index);
     if (child.IsEmpty()) {
       ADD_FAILURE();
       return false;
     }
     return child->IsNull();
   }
@@ skipping 37 matching lines @@
     if (expected_value) {
       base::Value* temp = NULL;
       ASSERT_TRUE(list->Get(0, &temp));
       EXPECT_EQ(expected_type, temp->GetType());
       EXPECT_TRUE(expected_value->Equals(temp));
     } else {
       // Arrays should preserve their length, and convert unconvertible
       // types into null.
       base::Value* temp = NULL;
       ASSERT_TRUE(list->Get(0, &temp));
-      EXPECT_EQ(base::Value::TYPE_NULL, temp->GetType());
+      EXPECT_EQ(base::Value::Type::NONE, temp->GetType());
     }
   }
 
   v8::Isolate* isolate_;
 
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 };
 
 TEST_F(V8ValueConverterImplTest, BasicRoundTrip) {
@@ skipping 174 matching lines @@
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
   v8::Local<v8::RegExp> regex(v8::RegExp::New(
       v8::String::NewFromUtf8(isolate_, "."), v8::RegExp::kNone));
 
   V8ValueConverterImpl converter;
   TestWeirdType(converter, v8::Undefined(isolate_),
-                base::Value::TYPE_NULL,  // Arbitrary type, result is NULL.
+                base::Value::Type::NONE,  // Arbitrary type, result is NULL.
                 std::unique_ptr<base::Value>());
   TestWeirdType(converter, v8::Date::New(isolate_, 1000),
-                base::Value::TYPE_DICTIONARY,
+                base::Value::Type::DICTIONARY,
                 std::unique_ptr<base::Value>(new base::DictionaryValue()));
-  TestWeirdType(converter, regex, base::Value::TYPE_DICTIONARY,
+  TestWeirdType(converter, regex, base::Value::Type::DICTIONARY,
                 std::unique_ptr<base::Value>(new base::DictionaryValue()));
 
   converter.SetDateAllowed(true);
   TestWeirdType(converter, v8::Date::New(isolate_, 1000),
-                base::Value::TYPE_DOUBLE,
+                base::Value::Type::DOUBLE,
                 std::unique_ptr<base::Value>(new base::FundamentalValue(1.0)));
 
   converter.SetRegExpAllowed(true);
-  TestWeirdType(converter, regex, base::Value::TYPE_STRING,
+  TestWeirdType(converter, regex, base::Value::Type::STRING,
                 std::unique_ptr<base::Value>(new base::StringValue("/./")));
 }
 
 TEST_F(V8ValueConverterImplTest, Prototype) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
   v8::MicrotasksScope microtasks(
       isolate_, v8::MicrotasksScope::kDoNotRunMicrotasks);
@@ skipping 689 matching lines @@
   EXPECT_TRUE(
       base::Value::Equals(reference_number_value.get(), number_value.get()));
 
   v8::Local<v8::Primitive> undefined(v8::Undefined(isolate_));
   std::unique_ptr<base::Value> undefined_value(
       converter.FromV8Value(undefined, context));
   EXPECT_FALSE(undefined_value);
 }
 
 }  // namespace content