[WIP] bindings: Introduce PropertyBag

bindings: Add PropertyBag

This is a work-in-progress CL and not intended to land.
(This CL doesn't pass all layout tests now)

To implement IDL dictionaries, we need a helper class that converts
a V8 object's properties to native values. Currently DictionaryHelper
does the job, but it's very complicated and difficult to extend.

Using DictionaryHelper to implement IDL dictionaries will add
further mess and I'd like to avoid that. However, it's somewhat
difficult to clean up DictionaryHelper at this point.

So I'd like to add a new class called PropertyBag for IDL
dictionaries implementation. This class does a similar job to
DictionaryHelper, but makes use of the CG and template specialization
to reduce manually-written code.

The idea is:
- The GC generates T -> V8T conversion traits (PropertyBagTraits).
- Add template functions which convert a V8 value to a native value
  in V8Binding.h (called nativeValueMayFail).
  These functions are used by PropertyBag::getInternal().                                                                               
- PropertyBag has one get() method and some getInternal() methods.
  getInternal() will be defined for container types and types which
  require special handling.
- We no longer need to add template specialization manually.

Once we implement IDL dictionaries, we should be able to remove
DictionaryHelper. However, DictionaryHelper is also used to initialize
EventInits so we need to replace it with PropertyBag.
In this CL, I added EventInitInitializer class to show how we can use                                                                   
PropertyBag to initialize EventInits.

This CL removed DictionaryHelper, but I don't think we can do it now.
My current plan is:
- Add the minimum PropertyBag implementation for IDL dictionaries.
  (at this point, we will have some code duplication)
- Implement all IDL dictionaries we need.
- Use PropertyBag to initialize EventInits.
- Remove Dictionary(Helper) from blink side.

WDYT? If this approach sounds reasonable, I'll create CLs for actual review.

[bashi, 2014-09-05 12:19:32]

Patchset #1 (id:1) has been deleted

[bashi, 2014-09-05 12:19:46]

Patchset #1 (id:20001) has been deleted

[bashi, 2014-09-05 12:38:07]

bashi@chromium.org changed reviewers:
+ haraken@chromium.org, tasak@chromium.org

[bashi, 2014-09-09 00:10:23]

Patchset #1 (id:40001) has been deleted

[bashi, 2014-09-09 00:22:13]

Patchset #1 (id:60001) has been deleted

[bashi, 2014-09-09 00:27:39]

Forgot to publish... Could you glance at this CL? The key changes are in
Dictionary class, PropertyBag class, V8Binding.h and interface.cpp template.

[haraken, 2014-09-09 03:56:59]

Overall the approach looks good. This CL definitely decreases the mess of the
Dictionary implementation.

The only thing I don't fully understand is why we need nativeValueMayFail
templates in V8Binding.h. Would there be any way to avoid adding the templates?

[bashi, 2014-09-09 04:14:15]

On 2014/09/09 03:56:59, haraken wrote:
> Overall the approach looks good. This CL definitely decreases the mess of the
> Dictionary implementation.
> 
> The only thing I don't fully understand is why we need nativeValueMayFail
> templates in V8Binding.h. Would there be any way to avoid adding the
templates?

We can generate V8T -> T conversion automatically, but for primitive types and
container types, we need to write them manually (nativeValueMayFail and
getInternal in this CL). Maybe there is a way to avoid templates, but I can't
come up with a neat solution. Another thoughts:
- For container types, we can move getInternal() to nativeValueMayFail()
- We may want to integrate nativeValue and nativeValueMayFail by adding
ExceptionState* to nativeValue as an argument

Anyway, we can defer this refactoring. Once we implement IDL dictionaries, this
work should be much easier.

[haraken, 2014-09-09 04:17:36]

On 2014/09/09 04:14:15, bashi1 wrote:
> On 2014/09/09 03:56:59, haraken wrote:
> > Overall the approach looks good. This CL definitely decreases the mess of
the
> > Dictionary implementation.
> > 
> > The only thing I don't fully understand is why we need nativeValueMayFail
> > templates in V8Binding.h. Would there be any way to avoid adding the
> templates?
> 
> We can generate V8T -> T conversion automatically, but for primitive types and
> container types, we need to write them manually (nativeValueMayFail and
> getInternal in this CL). Maybe there is a way to avoid templates, but I can't
> come up with a neat solution. Another thoughts:
> - For container types, we can move getInternal() to nativeValueMayFail()
> - We may want to integrate nativeValue and nativeValueMayFail by adding
> ExceptionState* to nativeValue as an argument
> 
> Anyway, we can defer this refactoring. Once we implement IDL dictionaries,
this
> work should be much easier.

OK, let's get back to the issue later. What I'm concerned about is we have a lot
of value conversion methods. In my ideal world, we want to have only two
templates: one template for the V8 value => C++ value conversion and the other
template for the C++ value => the V8 value conversion.

[bashi, 2014-09-09 04:22:39]

On 2014/09/09 04:17:36, haraken wrote:
> On 2014/09/09 04:14:15, bashi1 wrote:
> > On 2014/09/09 03:56:59, haraken wrote:
> > > Overall the approach looks good. This CL definitely decreases the mess of
> the
> > > Dictionary implementation.
> > > 
> > > The only thing I don't fully understand is why we need nativeValueMayFail
> > > templates in V8Binding.h. Would there be any way to avoid adding the
> > templates?
> > 
> > We can generate V8T -> T conversion automatically, but for primitive types
and
> > container types, we need to write them manually (nativeValueMayFail and
> > getInternal in this CL). Maybe there is a way to avoid templates, but I
can't
> > come up with a neat solution. Another thoughts:
> > - For container types, we can move getInternal() to nativeValueMayFail()
> > - We may want to integrate nativeValue and nativeValueMayFail by adding
> > ExceptionState* to nativeValue as an argument
> > 
> > Anyway, we can defer this refactoring. Once we implement IDL dictionaries,
> this
> > work should be much easier.
> 
> OK, let's get back to the issue later. What I'm concerned about is we have a
lot
> of value conversion methods. In my ideal world, we want to have only two
> templates: one template for the V8 value => C++ value conversion and the other
> template for the C++ value => the V8 value conversion.

Yeah, we should have one pair of V8 value <=> C++ value conversion templates for
each T in an ideal world. V8Binding.h has too many conversions...