tree a8d8c2cec202be753b3d558e320cf981c6983bb8
parent 85c532b35b53836bebfdb8f8832905d5f313cf47
author tsepez <tsepez@chromium.org> 1484779098 -0800
committer Commit bot <commit-bot@chromium.org> 1484779098 -0800

Tidy FXJS_V8, backfill tests.

Move checks performed as part of JS_Value's object and array
handling back into FXJS, to ease removal of JS_Value in the future.

Remove some convenience routines in FXJS for objects, to shrink
API to be covered during testing.

Change some naming (number => double, string => widestring) to
make it clearer when there is a C++ type involved.

BUG=

Review-Url: https://codereview.chromium.org/2637503002
