Switch generated dictionary binding code to Chromium style.

This change alters the code that is generated for dictionaries to use
Chromium variable names.

Change-Id: I5db361a1ef41dd134b2a2bf2e9af2cae14d17ad0
Reviewed-on: https://chromium-review.googlesource.com/1247232Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Commit-Queue: Adam Langley <agl@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595367}

third_party/blink/renderer/bindings/scripts/v8_dictionary.py

@@ -137,9 +137,10 @@ def member_context(dictionary, member):
         return cpp_default_value, v8_default_value
 
     cpp_default_value, v8_default_value = default_values()
-    cpp_value = member.name + 'CppValue'
-    v8_value = member.name + 'Value'
-    has_value_or_default = member.name + 'HasValueOrDefault'
+    snake_case_name = to_snake_case(member.name)
+    cpp_value = snake_case_name + "_cpp_value"
+    v8_value = snake_case_name + "_value"
+    has_value_or_default = snake_case_name + "_has_value_or_default"
     getter_name = getter_name_for_dictionary_member(member)
     is_deprecated_dictionary = unwrapped_idl_type.name == 'Dictionary'
 

third_party/blink/renderer/bindings/tests/results/core/v8_test_dictionary_derived.cc

@@ -48,61 +48,61 @@ void V8TestDictionaryDerivedImplementedAs::ToImpl(v8::Isolate* isolate, v8::Loca
   const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryDerivedImplementedAsKeys(isolate);
   v8::TryCatch block(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> derivedStringMemberValue;
-  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&derivedStringMemberValue)) {
+  v8::Local<v8::Value> derived_string_member_value;
+  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&derived_string_member_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (derivedStringMemberValue.IsEmpty() || derivedStringMemberValue->IsUndefined()) {
+  if (derived_string_member_value.IsEmpty() || derived_string_member_value->IsUndefined()) {
     // Do nothing.
   } else {
-    V8StringResource<> derivedStringMemberCppValue = derivedStringMemberValue;
-    if (!derivedStringMemberCppValue.Prepare(exceptionState))
+    V8StringResource<> derived_string_member_cpp_value = derived_string_member_value;
+    if (!derived_string_member_cpp_value.Prepare(exceptionState))
       return;
-    impl.setDerivedStringMember(derivedStringMemberCppValue);
+    impl.setDerivedStringMember(derived_string_member_cpp_value);
   }
 
-  v8::Local<v8::Value> derivedStringMemberWithDefaultValue;
-  if (!v8Object->Get(context, keys[1].Get(isolate)).ToLocal(&derivedStringMemberWithDefaultValue)) {
+  v8::Local<v8::Value> derived_string_member_with_default_value;
+  if (!v8Object->Get(context, keys[1].Get(isolate)).ToLocal(&derived_string_member_with_default_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (derivedStringMemberWithDefaultValue.IsEmpty() || derivedStringMemberWithDefaultValue->IsUndefined()) {
+  if (derived_string_member_with_default_value.IsEmpty() || derived_string_member_with_default_value->IsUndefined()) {
     // Do nothing.
   } else {
-    V8StringResource<> derivedStringMemberWithDefaultCppValue = derivedStringMemberWithDefaultValue;
-    if (!derivedStringMemberWithDefaultCppValue.Prepare(exceptionState))
+    V8StringResource<> derived_string_member_with_default_cpp_value = derived_string_member_with_default_value;
+    if (!derived_string_member_with_default_cpp_value.Prepare(exceptionState))
       return;
-    impl.setDerivedStringMemberWithDefault(derivedStringMemberWithDefaultCppValue);
+    impl.setDerivedStringMemberWithDefault(derived_string_member_with_default_cpp_value);
   }
 
-  v8::Local<v8::Value> requiredLongMemberValue;
-  if (!v8Object->Get(context, keys[2].Get(isolate)).ToLocal(&requiredLongMemberValue)) {
+  v8::Local<v8::Value> required_long_member_value;
+  if (!v8Object->Get(context, keys[2].Get(isolate)).ToLocal(&required_long_member_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (requiredLongMemberValue.IsEmpty() || requiredLongMemberValue->IsUndefined()) {
+  if (required_long_member_value.IsEmpty() || required_long_member_value->IsUndefined()) {
     exceptionState.ThrowTypeError("required member requiredLongMember is undefined.");
     return;
   } else {
-    int32_t requiredLongMemberCppValue = NativeValueTraits<IDLLong>::NativeValue(isolate, requiredLongMemberValue, exceptionState, kNormalConversion);
+    int32_t required_long_member_cpp_value = NativeValueTraits<IDLLong>::NativeValue(isolate, required_long_member_value, exceptionState, kNormalConversion);
     if (exceptionState.HadException())
       return;
-    impl.setRequiredLongMember(requiredLongMemberCppValue);
+    impl.setRequiredLongMember(required_long_member_cpp_value);
   }
 
-  v8::Local<v8::Value> stringOrDoubleSequenceMemberValue;
-  if (!v8Object->Get(context, keys[3].Get(isolate)).ToLocal(&stringOrDoubleSequenceMemberValue)) {
+  v8::Local<v8::Value> string_or_double_sequence_member_value;
+  if (!v8Object->Get(context, keys[3].Get(isolate)).ToLocal(&string_or_double_sequence_member_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (stringOrDoubleSequenceMemberValue.IsEmpty() || stringOrDoubleSequenceMemberValue->IsUndefined()) {
+  if (string_or_double_sequence_member_value.IsEmpty() || string_or_double_sequence_member_value->IsUndefined()) {
     // Do nothing.
   } else {
-    HeapVector<StringOrDouble> stringOrDoubleSequenceMemberCppValue = NativeValueTraits<IDLSequence<StringOrDouble>>::NativeValue(isolate, stringOrDoubleSequenceMemberValue, exceptionState);
+    HeapVector<StringOrDouble> string_or_double_sequence_member_cpp_value = NativeValueTraits<IDLSequence<StringOrDouble>>::NativeValue(isolate, string_or_double_sequence_member_value, exceptionState);
     if (exceptionState.HadException())
       return;
-    impl.setStringOrDoubleSequenceMember(stringOrDoubleSequenceMemberCppValue);
+    impl.setStringOrDoubleSequenceMember(string_or_double_sequence_member_cpp_value);
   }
 }
 
@@ -119,52 +119,52 @@ bool toV8TestDictionaryDerivedImplementedAs(const TestDictionaryDerivedImplement
 
   const v8::Eternal<v8::Name>* keys = eternalV8TestDictionaryDerivedImplementedAsKeys(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> derivedStringMemberValue;
-  bool derivedStringMemberHasValueOrDefault = false;
+  v8::Local<v8::Value> derived_string_member_value;
+  bool derived_string_member_has_value_or_default = false;
   if (impl.hasDerivedStringMember()) {
-    derivedStringMemberValue = V8String(isolate, impl.derivedStringMember());
-    derivedStringMemberHasValueOrDefault = true;
+    derived_string_member_value = V8String(isolate, impl.derivedStringMember());
+    derived_string_member_has_value_or_default = true;
   }
-  if (derivedStringMemberHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), derivedStringMemberValue))) {
+  if (derived_string_member_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), derived_string_member_value))) {
     return false;
   }
 
-  v8::Local<v8::Value> derivedStringMemberWithDefaultValue;
-  bool derivedStringMemberWithDefaultHasValueOrDefault = false;
+  v8::Local<v8::Value> derived_string_member_with_default_value;
+  bool derived_string_member_with_default_has_value_or_default = false;
   if (impl.hasDerivedStringMemberWithDefault()) {
-    derivedStringMemberWithDefaultValue = V8String(isolate, impl.derivedStringMemberWithDefault());
-    derivedStringMemberWithDefaultHasValueOrDefault = true;
+    derived_string_member_with_default_value = V8String(isolate, impl.derivedStringMemberWithDefault());
+    derived_string_member_with_default_has_value_or_default = true;
   } else {
-    derivedStringMemberWithDefaultValue = V8String(isolate, "default string value");
-    derivedStringMemberWithDefaultHasValueOrDefault = true;
+    derived_string_member_with_default_value = V8String(isolate, "default string value");
+    derived_string_member_with_default_has_value_or_default = true;
   }
-  if (derivedStringMemberWithDefaultHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[1].Get(isolate), derivedStringMemberWithDefaultValue))) {
+  if (derived_string_member_with_default_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[1].Get(isolate), derived_string_member_with_default_value))) {
     return false;
   }
 
-  v8::Local<v8::Value> requiredLongMemberValue;
-  bool requiredLongMemberHasValueOrDefault = false;
+  v8::Local<v8::Value> required_long_member_value;
+  bool required_long_member_has_value_or_default = false;
   if (impl.hasRequiredLongMember()) {
-    requiredLongMemberValue = v8::Integer::New(isolate, impl.requiredLongMember());
-    requiredLongMemberHasValueOrDefault = true;
+    required_long_member_value = v8::Integer::New(isolate, impl.requiredLongMember());
+    required_long_member_has_value_or_default = true;
   } else {
     NOTREACHED();
   }
-  if (requiredLongMemberHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[2].Get(isolate), requiredLongMemberValue))) {
+  if (required_long_member_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[2].Get(isolate), required_long_member_value))) {
     return false;
   }
 
-  v8::Local<v8::Value> stringOrDoubleSequenceMemberValue;
-  bool stringOrDoubleSequenceMemberHasValueOrDefault = false;
+  v8::Local<v8::Value> string_or_double_sequence_member_value;
+  bool string_or_double_sequence_member_has_value_or_default = false;
   if (impl.hasStringOrDoubleSequenceMember()) {
-    stringOrDoubleSequenceMemberValue = ToV8(impl.stringOrDoubleSequenceMember(), creationContext, isolate);
-    stringOrDoubleSequenceMemberHasValueOrDefault = true;
+    string_or_double_sequence_member_value = ToV8(impl.stringOrDoubleSequenceMember(), creationContext, isolate);
+    string_or_double_sequence_member_has_value_or_default = true;
   }
-  if (stringOrDoubleSequenceMemberHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[3].Get(isolate), stringOrDoubleSequenceMemberValue))) {
+  if (string_or_double_sequence_member_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[3].Get(isolate), string_or_double_sequence_member_value))) {
     return false;
   }
 

third_party/blink/renderer/bindings/tests/results/core/v8_test_interface_event_init.cc

@@ -44,18 +44,18 @@ void V8TestInterfaceEventInit::ToImpl(v8::Isolate* isolate, v8::Local<v8::Value>
   const v8::Eternal<v8::Name>* keys = eternalV8TestInterfaceEventInitKeys(isolate);
   v8::TryCatch block(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> stringMemberValue;
-  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&stringMemberValue)) {
+  v8::Local<v8::Value> string_member_value;
+  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&string_member_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
+  if (string_member_value.IsEmpty() || string_member_value->IsUndefined()) {
     // Do nothing.
   } else {
-    V8StringResource<> stringMemberCppValue = stringMemberValue;
-    if (!stringMemberCppValue.Prepare(exceptionState))
+    V8StringResource<> string_member_cpp_value = string_member_value;
+    if (!string_member_cpp_value.Prepare(exceptionState))
       return;
-    impl.setStringMember(stringMemberCppValue);
+    impl.setStringMember(string_member_cpp_value);
   }
 }
 
@@ -72,14 +72,14 @@ bool toV8TestInterfaceEventInit(const TestInterfaceEventInit& impl, v8::Local<v8
 
   const v8::Eternal<v8::Name>* keys = eternalV8TestInterfaceEventInitKeys(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> stringMemberValue;
-  bool stringMemberHasValueOrDefault = false;
+  v8::Local<v8::Value> string_member_value;
+  bool string_member_has_value_or_default = false;
   if (impl.hasStringMember()) {
-    stringMemberValue = V8String(isolate, impl.stringMember());
-    stringMemberHasValueOrDefault = true;
+    string_member_value = V8String(isolate, impl.stringMember());
+    string_member_has_value_or_default = true;
   }
-  if (stringMemberHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), stringMemberValue))) {
+  if (string_member_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), string_member_value))) {
     return false;
   }
 

third_party/blink/renderer/bindings/tests/results/core/v8_test_permissive_dictionary.cc

@@ -39,18 +39,18 @@ void V8TestPermissiveDictionary::ToImpl(v8::Isolate* isolate, v8::Local<v8::Valu
   const v8::Eternal<v8::Name>* keys = eternalV8TestPermissiveDictionaryKeys(isolate);
   v8::TryCatch block(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> booleanMemberValue;
-  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&booleanMemberValue)) {
+  v8::Local<v8::Value> boolean_member_value;
+  if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&boolean_member_value)) {
     exceptionState.RethrowV8Exception(block.Exception());
     return;
   }
-  if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
+  if (boolean_member_value.IsEmpty() || boolean_member_value->IsUndefined()) {
     // Do nothing.
   } else {
-    bool booleanMemberCppValue = NativeValueTraits<IDLBoolean>::NativeValue(isolate, booleanMemberValue, exceptionState);
+    bool boolean_member_cpp_value = NativeValueTraits<IDLBoolean>::NativeValue(isolate, boolean_member_value, exceptionState);
     if (exceptionState.HadException())
       return;
-    impl.setBooleanMember(booleanMemberCppValue);
+    impl.setBooleanMember(boolean_member_cpp_value);
   }
 }
 
@@ -64,14 +64,14 @@ v8::Local<v8::Value> TestPermissiveDictionary::ToV8Impl(v8::Local<v8::Object> cr
 bool toV8TestPermissiveDictionary(const TestPermissiveDictionary& impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
   const v8::Eternal<v8::Name>* keys = eternalV8TestPermissiveDictionaryKeys(isolate);
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Value> booleanMemberValue;
-  bool booleanMemberHasValueOrDefault = false;
+  v8::Local<v8::Value> boolean_member_value;
+  bool boolean_member_has_value_or_default = false;
   if (impl.hasBooleanMember()) {
-    booleanMemberValue = v8::Boolean::New(isolate, impl.booleanMember());
-    booleanMemberHasValueOrDefault = true;
+    boolean_member_value = v8::Boolean::New(isolate, impl.booleanMember());
+    boolean_member_has_value_or_default = true;
   }
-  if (booleanMemberHasValueOrDefault &&
-      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), booleanMemberValue))) {
+  if (boolean_member_has_value_or_default &&
+      !V8CallBoolean(dictionary->CreateDataProperty(context, keys[0].Get(isolate), boolean_member_value))) {
     return false;
   }