Fix JavaScript property ordering issue that was breaking js_array_test on FireFox

tests/html/js_array_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 @Js("ArrayTest.Util")
 library js_array_test;
 
 import 'dart:html';
 
 import 'dart:js' as js;
@@ skipping 112 matching lines @@
   },
 
   // TODO(jacobr): add a test that distinguishes reduce from reduceRight.
   reduceRightSumDoubledElements: function(array) {
     return array.reduceRight(function(previousValue, currentValue) {
           return previousValue + currentValue*2;
         },
         0);
   },
 
-  getOwnPropertyDescriptorJson: function(array, property) {
-    return JSON.stringify(Object.getOwnPropertyDescriptor(array, property));
+  getOwnPropertyDescriptor: function(array, property) {
+    return Object.getOwnPropertyDescriptor(array, property);
   },
 
   setLength: function(array, len) {
     return array.length = len;
   },
 
   getValue: function(obj, index) {
     return obj[index];
   },
 
   setValue: function(obj, index, value) {
     return obj[index] = value;
   },
 
   // Calling a method from Dart List on an arbitrary target object.
   callListMethodOnTarget: function(dartArray, target, methodName, args) {
     return dartArray[methodName].apply(target, args);
   },
 
   newArray: function() { return []; },
 
   newLiteral: function() { return {}; },
 
 };
 """);
 }
 
 @Js()
+class PropertyDescriptor {
+  external get value;
+  external bool get writable;
+  external bool get enumerable;
+  external bool get configurable;
+}
+
+@Js()
 class SimpleJsLiteralClass {
   external get foo;
 }
 
 class Foo {}
 
 @Js()
 external callJsMethod(List array, String methodName, List args);
 
 callIndexOf(List array, value) => callJsMethod(array, "indexOf", [value]);
@@ skipping 50 matching lines @@
 @Js()
 external mapAddIndexToEachElement(List array);
 @Js()
 external reduceSumDoubledElements(List array);
 
 // TODO(jacobr): add a test that distinguishes reduce from reduceRight.
 @Js()
 external reduceRightSumDoubledElements(List array);
 
 @Js()
-external getOwnPropertyDescriptorJson(List array, property);
+external PropertyDescriptor getOwnPropertyDescriptor(obj, property);
 
 @Js("setLength")
 external callSetLength(List array, length);
 
 @Js()
 external getValue(obj, index);
 
 @Js()
 external setValue(obj, index, value);
 
@@ skipping 248 matching lines @@
 
     test("is array", () {
       var list = ["a", "b"];
       expect(checkIsArray(list), isTrue);
     });
 
     test("property descriptors", () {
       // This test matters to make behavior consistent with JS native arrays
       // and to make devtools integration work well.
       var list = ["a", "b"];
-      expect(getOwnPropertyDescriptorJson(list, 0),
-          equals('{"value":"a",'
-              '"writable":true,'
-              '"enumerable":true,'
-              '"configurable":true}'));
+      var descriptor = getOwnPropertyDescriptor(list, 0);
 
-      expect(
-          getOwnPropertyDescriptorJson(list, "length"),
-          equals('{"value":2,'
-              '"writable":true,'
-              '"enumerable":false,'
-              '"configurable":false}'));
+      expect(descriptor.value, equals("a"));
+      expect(descriptor.writable, isTrue);
+      expect(descriptor.enumerable, isTrue);
+      expect(descriptor.configurable, isTrue);
+
+      descriptor = getOwnPropertyDescriptor(list, "length");
+      expect(descriptor.value, equals(2));
+      expect(descriptor.writable, isTrue);
+      expect(descriptor.enumerable, isFalse);
+      expect(descriptor.configurable, isFalse);
     });
 
     test("concat js arrays", () {
       var list = ["1", "2"];
       // Tests that calling the concat method from JS will flatten out JS arrays
       // We concat the array with "a", "b", ["c", "d"], 42, {foo: 10}
       // which should generate ["1", "2", "a", "b", ["c", "d"], 42, {foo: 10}]
       var ret = concatValues(list);
       expect(list.length, equals(2));
       expect(ret.length, equals(8));
@@ skipping 149 matching lines @@
     test('opaque proxy', () {
       // Dartium could easily support making LinkedList and all other classes
       // implementing List behave like a JavaScript array but that would
       // be challenging to implement in dart2js until browsers support ES6.
       var list = ["a", "b", "c", "d"];
       var listView = new UnmodifiableListView(list.getRange(1,3));
       expect(listView is List, isTrue);
       expect(listView.length, equals(2));
       expect(checkIsArray(listView), isFalse);
       expect(checkIsArray(listView.toList()), isTrue);
-      expect(getOwnPropertyDescriptorJson(
-          listView, "length"), equals("null"));
+      expect(getOwnPropertyDescriptor(
+          listView, "length"), equals(null));
     });
   });
   */
 }