IDL compiler: Improve IdlType.unwrap

Improves ease-of-use of IdlType.unwrap.

  idl_type.unwrap()  # Unwrap both of typedef and nullable
  idl_type.unwrap(typedef=True)  # Unwrap only typedef

This style works better when we'll add the third 'unwrappable'.

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

third_party/blink/renderer/bindings/scripts/web_idl/idl_type.py

@@ -180,17 +180,39 @@ class IdlType(WithExtendedAttributes, WithDebugInfo):
         """
         callback(self)
 
-    def unwrap(self, nullable=True, typedef=True):
+    def unwrap(self, nullable=None, typedef=None):
         """
         Returns the body part of the actual type, i.e. returns the interesting
         part of this type.
 
         Args:
-            nullable: Unwraps a nullable type and returns |inner_type| if True.
-            typedef: Dereferences a typedef type and returns |original_type| if
-                True.
+            nullable:
+            typedef:
+                All these arguments take tri-state value: True, False, or None.
+                True unwraps that type, False stops unwrapping that type.  All
+                of specified arguments' values must be consistent, and mixture
+                of True and False is not allowed.  Unspecified arguments are
+                automatically set to the opposite value.  If no argument is
+                specified, unwraps all types.
         """
-        return self
+        switches = {
+            'nullable': nullable,
+            'typedef': typedef,
+        }
+
+        value_counts = {None: 0, False: 0, True: 0}
+        for value in switches.itervalues():
+            assert value is None or isinstance(value, bool)
+            value_counts[value] += 1
+        assert value_counts[False] == 0 or value_counts[True] == 0, (
+            "Specify only True or False arguments.  Unspecified arguments are "
+            "automatically set to the opposite value.")
+        default = value_counts[True] == 0
+        for arg, value in switches.iteritems():
+            if value is None:
+                switches[arg] = default
+
+        return self._unwrap(switches)
 
     @property
     def does_include_nullable_type(self):
@@ -417,6 +439,9 @@ class IdlType(WithExtendedAttributes, WithDebugInfo):
         return '{}{}'.format(type_name_inner, ''.join(
             sorted(self.extended_attributes.keys())))
 
+    def _unwrap(self, switches):
+        return self
+
 
 class SimpleType(IdlType):
     """
@@ -656,12 +681,6 @@ class TypedefType(IdlType, WithIdentifier):
         callback(self)
         self.original_type.apply_to_all_composing_elements(callback)
 
-    def unwrap(self, nullable=True, typedef=True):
-        if typedef:
-            return self.original_type.unwrap(
-                nullable=nullable, typedef=typedef)
-        return self
-
     @property
     def does_include_nullable_type(self):
         return self.original_type.does_include_nullable_type
@@ -674,6 +693,11 @@ class TypedefType(IdlType, WithIdentifier):
     def original_type(self):
         return self._typedef.idl_type
 
+    def _unwrap(self, switches):
+        if switches['typedef']:
+            return self.original_type._unwrap(switches)
+        return self
+
 
 class _ArrayLikeType(IdlType):
     def __init__(self,
@@ -1050,11 +1074,6 @@ class NullableType(IdlType):
         callback(self)
         self.inner_type.apply_to_all_composing_elements(callback)
 
-    def unwrap(self, nullable=True, typedef=True):
-        if nullable:
-            return self.inner_type.unwrap(nullable=nullable, typedef=typedef)
-        return self
-
     @property
     def does_include_nullable_type(self):
         return True
@@ -1066,3 +1085,8 @@ class NullableType(IdlType):
     @property
     def inner_type(self):
         return self._inner_type
+
+    def _unwrap(self, switches):
+        if switches['nullable']:
+            return self.inner_type._unwrap(switches)
+        return self