Add keys(), values() and entries() methods on iterable<> interfaces

LayoutTests/http/tests/fetch/script-tests/headers.js

 if (self.importScripts) {
   importScripts('../resources/fetch-test-helpers.js');
 }
 
 test(function() {
     function size(headers) {
       var count = 0;
       for (var header of headers) {
         ++count;
       }
       return count;
     }
 
-    var expectedMap = {
+    var expectedValueMap = {
       'content-language': 'ja',
       'content-type': 'text/html; charset=UTF-8',
       'x-fetch-test': 'response test field'
     };
 
     var headers = new Headers;
     headers.set('Content-Language', 'ja');
     headers.set('Content-Type', 'text/html; charset=UTF-8');
     headers.set('X-Fetch-Test', 'text/html; charset=UTF-8');
 
     assert_equals(size(headers), 3, 'headers size should match');
 
     // 'has()', 'get()'
     var key = 'Content-Type';
     assert_true(headers.has(key));
     assert_true(headers.has(key.toUpperCase()));
-    assert_equals(headers.get(key), expectedMap[key.toLowerCase()]);
+    assert_equals(headers.get(key), expectedValueMap[key.toLowerCase()]);
     assert_equals(headers.get(key.toUpperCase()),
-                  expectedMap[key.toLowerCase()]);
+                  expectedValueMap[key.toLowerCase()]);
     assert_equals(headers.get('dummy'), null);
     assert_false(headers.has('dummy'));
 
     // 'delete()'
     var deleteKey = 'Content-Type';
     headers.delete(deleteKey);
     assert_equals(size(headers), 2, 'headers size should have -1 size');
-    Object.keys(expectedMap).forEach(function(key) {
+    Object.keys(expectedValueMap).forEach(function(key) {
         if (key == deleteKey.toLowerCase())
           assert_false(headers.has(key));
         else
           assert_true(headers.has(key));
       });
 
     // 'set()'
     var testCasesForSet = [
       // For a new key/value pair.
       { key: 'Cache-Control',
@@ skipping 23 matching lines @@
         var value = testCase.value;
         var expectedValue = ('expectedValue' in testCase) ?
           testCase.expectedValue : testCase.value;
         expectedHeaderSize = testCase.isNewEntry ?
           (expectedHeaderSize + 1) : expectedHeaderSize;
 
         headers.set(key, value);
         assert_true(headers.has(key));
         assert_equals(headers.get(key), expectedValue);
         if (testCase.isUpdate)
-          assert_true(headers.get(key) != expectedMap[key.toLowerCase()]);
+          assert_not_equals(headers.get(key), expectedValueMap[key.toLowerCase()]);
         assert_equals(size(headers), expectedHeaderSize);
 
-        // Update expectedMap too for forEach() test below.
-        expectedMap[key.toLowerCase()] = expectedValue;
+        // Update expectedValueMap too for forEach() test below.
+        expectedValueMap[key.toLowerCase()] = expectedValue;
       });
 
     // '[Symbol.iterator]()'
     for (var header of headers) {
       var key = header[0], value = header[1];
-      assert_true(key != deleteKey.toLowerCase());
-      assert_true(key in expectedMap);
-      assert_equals(headers.get(key), expectedMap[key]);
+      assert_not_equals(key, deleteKey.toLowerCase());
+      assert_true(key in expectedValueMap);
+      assert_equals(headers.get(key), expectedValueMap[key]);
+      assert_equals(value, expectedValueMap[key]);
+    }
+
+    // 'keys()'
+    for (var key of headers.keys()) {
+      assert_not_equals(key, deleteKey.toLowerCase());
+      assert_true(key in expectedValueMap);
+      assert_equals(headers.get(key), expectedValueMap[key]);
+    }
+
+    // 'values()'
+    var expectedKeyMap = {};
+    for (var key in expectedValueMap)
+      expectedKeyMap[expectedValueMap[key]] = key;
+    for (var value of headers.values()) {
+      assert_true(value in expectedKeyMap);
+      var key = expectedKeyMap[value];
+      assert_not_equals(key, deleteKey.toLowerCase());
+    }
+
+    // 'entries()'
+    for (var header of headers.entries()) {
+      var key = header[0], value = header[1];
+      assert_not_equals(key, deleteKey.toLowerCase());
+      assert_true(key in expectedValueMap);
+      assert_equals(headers.get(key), expectedValueMap[key]);
+      assert_equals(value, expectedValueMap[key]);
     }
 
     // 'append()', 'getAll()'
     var allValues = headers.getAll('X-Fetch-Test');
     assert_equals(allValues.length, 1);
     assert_equals(size(headers), 4);
     headers.append('X-FETCH-TEST', 'response test field - append');
     assert_equals(size(headers), 5, 'headers size should increase by 1.');
     assert_equals(headers.get('X-FETCH-Test'),
                   'response test field - updated',
@@ skipping 108 matching lines @@
                   'new Headers with a sequence with less than two strings ' +
                   'should throw');
     assert_throws({name: 'TypeError'},
                   function() { var headers = new Headers([['a', 'b'],
                                                           ['x', 'y', 'z']]); },
                   'new Headers with a sequence with more than two strings ' +
                   'should throw');
   }, 'Headers');
 
 done();