ChangeLog

2012-05-22  Peter Rybin  <peter.rybin@gmail.com>

        Web Inspector: CodeGeneratorInspector.py: protect typed API from C++ implicit float to int cast

        https://bugs.webkit.org/show_bug.cgi?id=87183

        Reviewed by NOBODY (OOPS!).

        An intermediate C++ class is introduced that uses C++ template technique to control actual type

        of its constructor argument.

        All input parameters of type "int" now have type ExactlyInt. 

        * inspector/CodeGeneratorInspector.py:

        (TypeModel.RefPtrBased):

        (TypeModel.Enum):

        (TypeModel.ValueType):

        (TypeModel.ExactlyInt):

        (TypeModel.ExactlyInt.__init__):

        (TypeModel.ExactlyInt.get_input_param_type_text):

        (TypeModel.init_class):

        (ExactlyInt):

        (that):

        (ExactlyIntHelper):

2012-05-21  Joshua Bell  <jsbell@chromium.org>

        IndexedDB: Store key paths in IDBKeyPath type instead of String

Source/WebCore/inspector/CodeGeneratorInspector.py

@@class CommandReturnPassModel:

class TypeModel:

625 class RefPtrBased:

625 class RefPtrBased(object):

        def __init__(self, class_name):

            self.class_name = class_name

            self.optional = False

@@class TypeModel:

        def get_event_setter_expression_pattern():

            return "%s"

649 class Enum:

649 class Enum(object):

        def __init__(self, base_type_name):

            self.type_name = base_type_name + "::Enum"

@@class TypeModel:

        def get_event_setter_expression_pattern():

            return "%s"

682 class ValueType:

682 class ValueType(object):

        def __init__(self, type_name, is_heavy):

            self.type_name = type_name

            self.is_heavy = is_heavy

@@class TypeModel:

            else:

                return self.type_name

        def get_opt_output_type_(self):

            return self.type_name

        @staticmethod

        def get_event_setter_expression_pattern():

            return "%s"

@@class TypeModel:

                return self

            def get_command_return_pass_model(self):

711 return CommandReturnPassModel.OptOutput(self.base.type_~~name~~)

714 return CommandReturnPassModel.OptOutput(self.base.get_opt_output_type_())

            def get_input_param_type_text(self):

                return "const %s* const" % self.base.type_name

@@class TypeModel:

            def get_event_setter_expression_pattern():

                return "*%s"

    class ExactlyInt(ValueType):

        def __init__(self):

            TypeModel.ValueType.__init__(self, "int", False)

        def get_input_param_type_text(self):

            return "TypeBuilder::ExactlyInt"

        def get_opt_output_type_(self):

            return "TypeBuilder::ExactlyInt"

    @classmethod

    def init_class(cls):

        cls.Bool = cls.ValueType("bool", False)

723 cls.Int = cls.Va~~lueType("int", False~~)

736 cls.Int = cls.ExactlyInt()

724737 cls.Number = cls.ValueType("double", False)

725 cls.String = cls.ValueType("String", True)

738 cls.String = cls.ValueType("String", True,)

        cls.Object = cls.RefPtrBased("InspectorObject")

        cls.Array = cls.RefPtrBased("InspectorArray")

        cls.Any = cls.RefPtrBased("InspectorValue")

@@private:

};

// A small trancient wrapper around int type, that can be used as a funciton parameter type

// cleverly diallowing C++ implicit casts from float or double.

class ExactlyInt {

public:

    template<typename T>

    ExactlyInt(T t);

    ExactlyInt() {}

    operator int() { return m_value; }

private:

    int m_value;

};

// A helper template class that has 'cast' method for all parameter types except float and double.

template<typename T>

class ExactlyIntHelper {

public:

    static inline int cast(T t) { return t; }

};

template<> class ExactlyIntHelper<float> { /* no cast method for float */ };

template<> class ExactlyIntHelper<double> { /* no cast method for double */ };

template<typename T>

inline ExactlyInt::ExactlyInt(T t) : m_value(ExactlyIntHelper<T>::cast(t)) {}

// This class provides "Traits" type for the input type T. It is programmed using C++ template specialization

// technique. By default it simply takes "ItemTraits" type from T, but it doesn't work with the base types.

template<typename T>