CodeGen: Introduce fooNonNull and hasFooNonNull for dictionary members

This CL introduces following methods for dictionary members whose type
is nullabe.  These methods are migration adapters, and will be removed
after IDL compiler migraiton.

- fooNonNull(): Returns a non-null type value for a member |foo|.
  It crashes if foo() is missing or has a null value.
- hasFooNonNull(): Returns true iff |foo| has a non-null value.

In practice, however, they are aliases of foo() and hasFoo() in the
running IDL compiler.  We are changing behaviors of foo() and hasFoo()
precisely in the new compiler, and expect these new methods work as
migration adapters.


Bug: 839389
Change-Id: If19479779ea3d19b498e23a5001aabd38366a2ac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2215648
Commit-Queue: Hitoshi Yoshida <peria@chromium.org>
Reviewed-by: Yuki Shiino <yukishiino@chromium.org>
Cr-Commit-Position: refs/heads/master@{#772269}

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

@@ -33,6 +33,11 @@ def getter_name_for_dictionary_member(member):
     return NameStyleConverter(name).to_lower_camel_case()
 
 
+def non_null_getter_name_for_dictionary_member(member):
+    name = v8_utilities.cpp_name(member)
+    return NameStyleConverter('{}_non_null'.format(name)).to_lower_camel_case()
+
+
 def setter_name_for_dictionary_member(member):
     name = 'set_{}'.format(v8_utilities.cpp_name(member))
     return NameStyleConverter(name).to_lower_camel_case()
@@ -50,6 +55,11 @@ def has_method_name_for_dictionary_member(member):
     return name.to_lower_camel_case()
 
 
+def non_null_has_method_name_for_dictionary_member(member, for_non_null=False):
+    name = 'has_{}_non_null'.format(v8_utilities.cpp_name(member))
+    return NameStyleConverter(name).to_lower_camel_case()
+
+
 def unwrap_nullable_if_needed(idl_type):
     if idl_type.is_nullable:
         return idl_type.inner_type
@@ -343,20 +353,23 @@ def member_impl_context(member, interfaces_info, header_includes,
         'has_method_name':
         has_method_name_for_dictionary_member(member),
         'is_nullable':
-        idl_type.is_nullable,
+        member.idl_type.is_nullable,
         'is_traceable':
         idl_type.is_traceable,
         'member_cpp_type':
-        idl_type.cpp_type_args(
-            used_in_cpp_sequence=True,
-            extended_attributes=extended_attributes),
+        idl_type.cpp_type_args(used_in_cpp_sequence=True,
+                               extended_attributes=extended_attributes),
+        'non_null_getter_name':
+        non_null_getter_name_for_dictionary_member(member),
+        'non_null_has_method_name':
+        non_null_has_method_name_for_dictionary_member(member),
         'null_setter_name':
         null_setter_name_for_dictionary_member(member),
         'nullable_indicator_name':
         nullable_indicator_name,
         'rvalue_cpp_type':
-        idl_type.cpp_type_args(
-            used_as_rvalue_type=True, extended_attributes=extended_attributes),
+        idl_type.cpp_type_args(used_as_rvalue_type=True,
+                               extended_attributes=extended_attributes),
         'setter_inline':
         setter_inline,
         'setter_name':

third_party/blink/renderer/bindings/templates/dictionary_impl.h.tmpl

@@ -38,6 +38,18 @@ class {{exported}}{{cpp_class}} : public {{parent_cpp_class}} {
   {% if member.null_setter_name %}
   {{member.setter_inline}}void {{member.null_setter_name}}();
   {% endif %}
+  {% if member.is_nullable %}
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool {{member.non_null_has_method_name}}() const { return {{member.has_method_expression}}; }
+  // Returns the value if this member has a non-null value.  Call
+  // |{{member.non_null_has_method_name}}| in advance to check the condition.
+  {{member.rvalue_cpp_type}} {{member.non_null_getter_name}}() const {
+    DCHECK({{member.non_null_has_method_name}}());
+    return {{member.getter_expression}};
+  }
+  {% endif %}
 
   {% endfor %}
   v8::Local<v8::Value> ToV8Impl(v8::Local<v8::Object>, v8::Isolate*) const override;

third_party/blink/renderer/bindings/tests/results/core/test_dictionary.h

@@ -109,6 +109,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setDoubleOrNullMember(double);
   inline void setDoubleOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasDoubleOrNullMemberNonNull() const { return has_double_or_null_member_; }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasDoubleOrNullMemberNonNull| in advance to check the condition.
+  double doubleOrNullMemberNonNull() const {
+    DCHECK(hasDoubleOrNullMemberNonNull());
+    return double_or_null_member_;
+  }
 
   bool hasDoubleOrNullOrDoubleOrNullSequenceMember() const { return !double_or_null_or_double_or_null_sequence_member_.IsNull(); }
   const DoubleOrDoubleOrNullSequence& doubleOrNullOrDoubleOrNullSequenceMember() const {
@@ -149,6 +159,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setElementOrNullMember(Element*);
   inline void setElementOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasElementOrNullMemberNonNull() const { return has_element_or_null_member_; }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasElementOrNullMemberNonNull| in advance to check the condition.
+  Element* elementOrNullMemberNonNull() const {
+    DCHECK(hasElementOrNullMemberNonNull());
+    return element_or_null_member_;
+  }
 
   bool hasElementOrNullRecordMember() const { return has_element_or_null_record_member_; }
   const HeapVector<std::pair<String, Member<Element>>>& elementOrNullRecordMember() const {
@@ -176,6 +196,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setEnumOrNullMember(const String&);
   inline void setEnumOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasEnumOrNullMemberNonNull() const { return !enum_or_null_member_.IsNull(); }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasEnumOrNullMemberNonNull| in advance to check the condition.
+  const String& enumOrNullMemberNonNull() const {
+    DCHECK(hasEnumOrNullMemberNonNull());
+    return enum_or_null_member_;
+  }
 
   bool hasEnumSequenceMember() const { return has_enum_sequence_member_; }
   const Vector<String>& enumSequenceMember() const {
@@ -237,6 +267,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   void setObjectOrNullMember(ScriptValue);
   void setObjectOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasObjectOrNullMemberNonNull() const { return !(object_or_null_member_.IsEmpty() || object_or_null_member_.IsNull() || object_or_null_member_.IsUndefined()); }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasObjectOrNullMemberNonNull| in advance to check the condition.
+  ScriptValue objectOrNullMemberNonNull() const {
+    DCHECK(hasObjectOrNullMemberNonNull());
+    return object_or_null_member_;
+  }
 
   bool hasObjectOrNullSequenceMember() const { return has_object_or_null_sequence_member_; }
   const HeapVector<ScriptValue>& objectOrNullSequenceMember() const {
@@ -311,6 +351,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setStringOrNullMember(const String&);
   inline void setStringOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasStringOrNullMemberNonNull() const { return !string_or_null_member_.IsNull(); }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasStringOrNullMemberNonNull| in advance to check the condition.
+  const String& stringOrNullMemberNonNull() const {
+    DCHECK(hasStringOrNullMemberNonNull());
+    return string_or_null_member_;
+  }
 
   bool hasStringOrNullRecordMember() const { return has_string_or_null_record_member_; }
   const Vector<std::pair<String, String>>& stringOrNullRecordMember() const {
@@ -369,6 +419,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setTestInterfaceOrNullMember(TestInterfaceImplementation*);
   inline void setTestInterfaceOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasTestInterfaceOrNullMemberNonNull() const { return has_test_interface_or_null_member_; }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasTestInterfaceOrNullMemberNonNull| in advance to check the condition.
+  TestInterfaceImplementation* testInterfaceOrNullMemberNonNull() const {
+    DCHECK(hasTestInterfaceOrNullMemberNonNull());
+    return test_interface_or_null_member_;
+  }
 
   bool hasTestInterfaceSequenceMember() const { return has_test_interface_sequence_member_; }
   const HeapVector<Member<TestInterfaceImplementation>>& testInterfaceSequenceMember() const {
@@ -455,6 +515,16 @@ class CORE_EXPORT TestDictionary : public IDLDictionaryBase {
   }
   inline void setUsvStringOrNullMember(const String&);
   inline void setUsvStringOrNullMemberToNull();
+  // Migration adapters
+  // Returns true iff this member has a non-null value.  Returns false if the
+  // value is missing or a null value.
+  bool hasUsvStringOrNullMemberNonNull() const { return !usv_string_or_null_member_.IsNull(); }
+  // Returns the value if this member has a non-null value.  Call
+  // |hasUsvStringOrNullMemberNonNull| in advance to check the condition.
+  const String& usvStringOrNullMemberNonNull() const {
+    DCHECK(hasUsvStringOrNullMemberNonNull());
+    return usv_string_or_null_member_;
+  }
 
   v8::Local<v8::Value> ToV8Impl(v8::Local<v8::Object>, v8::Isolate*) const override;
   void Trace(Visitor*) const override;