DevTools: consistently use Maybe for optional values in the protocol generator.

third_party/WebKit/Source/platform/inspector_protocol/CodeGenerator.py

 # 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.
 
 import os.path
 import sys
 import string
 import optparse
 import re
 try:
@@ skipping 90 matching lines @@
 
 
 def create_user_type_definition(domain_name, type):
     return {
         "return_type": "PassOwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
         "pass_type": "PassOwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
         "to_pass_type": "%s.release()",
         "type": "OwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
         "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
         "create_type": "adoptPtr(new protocol::%s::%s())" % (domain_name, type["id"]),
-        "optional_type": "OwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "optional_pass_type": "PassOwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "from_optional_out": "%s.release()",
         "json_getter": "FromValue<protocol::%s::%s>::convert(getObject(%%s))" % (domain_name, type["id"]),
         "json_type": "TypeObject",
-        "nullable": True,
     }
 
 
 def create_object_type_definition():
     return {
         "return_type": "PassRefPtr<JSONObject>",
         "pass_type": "PassRefPtr<JSONObject>",
         "to_pass_type": "%s.release()",
         "type": "RefPtr<JSONObject>",
         "raw_type": "RefPtr<JSONObject>",
-        "optional_type": "RefPtr<JSONObject>",
-        "optional_pass_type": "PassRefPtr<JSONObject>",
-        "from_optional_out": "%s.release()",
         "json_getter": "getObject(%s)",
         "json_type": "TypeObject",
-        "nullable": True,
     }
 
 
 def create_any_type_definition():
     return {
         "return_type": "PassRefPtr<JSONValue>",
         "pass_type": "PassRefPtr<JSONValue>",
         "to_pass_type": "%s.release()",
         "type": "RefPtr<JSONValue>",
         "raw_type": "RefPtr<JSONValue>",
-        "optional_type": "RefPtr<JSONValue>",
-        "optional_pass_type": "PassRefPtr<JSONValue>",
-        "from_optional_out": "%s.release()",
         "json_getter": "getValue(%s)",
-        "nullable": True,
     }
 
 
 def create_primitive_type_definition(type):
     if type == "string":
         return {
             "return_type": "String",
             "pass_type": "const String&",
             "to_pass_type": "%s",
             "type": "String",
             "raw_type": "String",
-            "optional_type": "protocol::OptionalValue<String>",
-            "optional_pass_type": "const protocol::OptionalValue<String>&",
-            "from_optional_out": "%s.get()",
             "json_getter": "getString(%s)",
             "json_type": "TypeString",
-            "nullable": False,
         }
 
     typedefs = {
         "number": "double",
         "integer": "int",
         "boolean": "bool"
     }
     jsontypes = {
         "number": "TypeNumber",
         "integer": "TypeNumber",
         "boolean": "TypeBoolean",
     }
     return {
         "return_type": typedefs[type],
         "pass_type": typedefs[type],
         "to_pass_type": "%s",
         "type": typedefs[type],
         "raw_type": typedefs[type],
-        "optional_type": "protocol::OptionalValue<" + typedefs[type] + ">",
-        "optional_pass_type": "const protocol::OptionalValue<" + typedefs[type] + ">&",
-        "from_optional_out": "%s.get()",
         "json_getter": "get" + to_title_case(type) + "(%s)",
         "json_type": jsontypes[type],
-        "nullable": False,
     }
 
 type_definitions = {}
 type_definitions["string"] = create_primitive_type_definition("string")
 type_definitions["number"] = create_primitive_type_definition("number")
 type_definitions["integer"] = create_primitive_type_definition("integer")
 type_definitions["boolean"] = create_primitive_type_definition("boolean")
 type_definitions["object"] = create_object_type_definition()
 type_definitions["any"] = create_any_type_definition()
 
 
 def wrap_array_definition(type):
     return {
         "return_type": "PassOwnPtr<protocol::Array<%s>>" % type["raw_type"],
         "pass_type": "PassOwnPtr<protocol::Array<%s>>" % type["raw_type"],
         "to_pass_type": "%s.release()",
         "type": "OwnPtr<protocol::Array<%s>>" % type["raw_type"],
         "raw_type": "protocol::Array<%s>" % type["raw_type"],
         "create_type": "adoptPtr(new protocol::Array<%s>())" % type["raw_type"],
         "out_type": "protocol::Array<%s>&" % type["raw_type"],
-        "optional_type": "OwnPtr<protocol::Array<%s>>" % type["raw_type"],
-        "optional_pass_type": "PassOwnPtr<protocol::Array<%s>>" % type["raw_type"],
-        "from_optional_out": "%s.release()",
         "json_getter": "protocol::Array<%s>::runtimeCast(getArray(%%s))" % type["raw_type"],
         "json_type": "TypeArray",
-        "nullable": True,
     }
 
 
 def create_type_definitions():
     for domain in json_api["domains"]:
         if not ("types" in domain):
             continue
         for type in domain["types"]:
             if type["type"] == "object":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_user_type_definition(domain["domain"], type)
@@ skipping 42 matching lines @@
     h_file.write(h_template.render(template_context))
     cpp_file.write(cpp_template.render(template_context))
     h_file.close()
     cpp_file.close()
 
 
 jinja_env = initialize_jinja_env(output_dirname)
 generate("Dispatcher")
 generate("Frontend")
 generate("TypeBuilder")