[Extensions Bindings] Add enum support

extensions/renderer/api_binding_unittest.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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding.h"
@@ skipping 261 matching lines @@
   ExpectPass(binding_object, "obj.optionalIntAndCallback(function() {})",
              "[null]");
   ExpectFailure(binding_object, "obj.optionalIntAndCallback(1)", kError);
 
   ExpectPass(binding_object, "obj.optionalCallback(function() {})", "[]");
   ExpectPass(binding_object, "obj.optionalCallback()", "[]");
   ExpectPass(binding_object, "obj.optionalCallback(undefined)", "[]");
   ExpectFailure(binding_object, "obj.optionalCallback(0)", kError);
 }
 
+// Test that enum values are properly exposed on the binding object.
+TEST_F(APIBindingUnittest, EnumValues) {
+  const char kTypes[] =
+      "[{"
+      "  'id': 'first',"
+      "  'type': 'string',"
+      "  'enum': ['alpha', 'camelCase', 'Hyphen-ated',"
+      "           'SCREAMING', 'nums123', '42nums']"
+      "}, {"
+      "  'id': 'last',"
+      "  'type': 'string',"
+      "  'enum': [{'name': 'omega'}]"
+      "}]";
+
+  std::unique_ptr<base::ListValue> types = ListValueFromString(kTypes);
+  ASSERT_TRUE(types);
+  ArgumentSpec::RefMap refs;
+  APIBinding binding(
+      "test", nullptr, types.get(), nullptr,
+      base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
+      base::MakeUnique<APIBindingHooks>(binding::RunJSFunctionSync()), &refs);
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
+  v8::Local<v8::Object> binding_object = binding.CreateInstance(
+      context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
+
+  const char kExpected[] =
+      "{'ALPHA':'alpha','CAMEL_CASE':'camelCase','HYPHEN_ATED':'Hyphen-ated',"
+      "'NUMS123':'nums123','SCREAMING':'SCREAMING','_42NUMS':'42nums'}";
+  EXPECT_EQ(ReplaceSingleQuotes(kExpected),
+            GetStringPropertyFromObject(binding_object, context, "first"));
+  EXPECT_EQ(ReplaceSingleQuotes("{'OMEGA':'omega'}"),
+            GetStringPropertyFromObject(binding_object, context, "last"));
+}
+
 TEST_F(APIBindingUnittest, TypeRefsTest) {
   const char kTypes[] =
       "[{"
       "  'id': 'refObj',"
       "  'type': 'object',"
       "  'properties': {"
       "    'prop1': {'type': 'string'},"
       "    'prop2': {'type': 'integer', 'optional': true}"
       "  }"
       "}, {"
@@ skipping 39 matching lines @@
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
 
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
              "[{'prop1':'foo'}]");
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 2})",
              "[{'prop1':'foo','prop2':2}]");
   ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
                 kError);
   ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']");
   ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']");
+  ExpectPass(binding_object, "obj.takesRefEnum(obj.refEnum.BETA)", "['beta']");
   ExpectFailure(binding_object, "obj.takesRefEnum('gamma')", kError);
 }
 
 TEST_F(APIBindingUnittest, RestrictedAPIs) {
   const char kRestrictedFunctions[] =
       "[{"
       "  'name': 'allowedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'allowedTwo',"
@@ skipping 527 matching lines @@
     v8::Local<v8::Value> result =
         RunFunction(function, context, arraysize(args), args);
     ASSERT_FALSE(result.IsEmpty());
     std::unique_ptr<base::Value> json_result = V8ToBaseValue(result, context);
     ASSERT_TRUE(json_result);
     EXPECT_EQ("\"ping pong\"", ValueToString(*json_result));
   }
 }
 
 }  // namespace extensions