Revert "Don't use OwnPrototypeChainLength in GetOwnPropertyNames"

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 5735 matching lines @@
       isolate, content,
       JSReceiver::GetKeys(object, JSReceiver::INCLUDE_PROTOS));
 
   // Test again, since cache may have been built by preceding call.
   if (object->IsSimpleEnum()) return object->map();
 
   return *content;
 }
 
 
+// Find the length of the prototype chain that is to be handled as one. If a
+// prototype object is hidden it is to be viewed as part of the the object it
+// is prototype for.
+static int OwnPrototypeChainLength(JSObject* obj) {
+  int count = 1;
+  for (PrototypeIterator iter(obj->GetIsolate(), obj);
+       !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN); iter.Advance()) {
+    count++;
+  }
+  return count;
+}
+
+
 // Return the names of the own named properties.
 // args[0]: object
 // args[1]: PropertyAttributes as int
 RUNTIME_FUNCTION(Runtime_GetOwnPropertyNames) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 2);
   if (!args[0]->IsJSObject()) {
     return isolate->heap()->undefined_value();
   }
   CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
   CONVERT_SMI_ARG_CHECKED(filter_value, 1);
   PropertyAttributes filter = static_cast<PropertyAttributes>(filter_value);
 
+  // Skip the global proxy as it has no properties and always delegates to the
+  // real global object.
+  if (obj->IsJSGlobalProxy()) {
+    // Only collect names if access is permitted.
+    if (obj->IsAccessCheckNeeded() &&
+        !isolate->MayNamedAccess(
+            obj, isolate->factory()->undefined_value(), v8::ACCESS_KEYS)) {
+      isolate->ReportFailedAccessCheck(obj, v8::ACCESS_KEYS);
+      RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+      return *isolate->factory()->NewJSArray(0);
+    }
+    PrototypeIterator iter(isolate, obj);
+    obj = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+  }
+
+  // Find the number of objects making up this.
+  int length = OwnPrototypeChainLength(*obj);
+
   // Find the number of own properties for each of the objects.
+  ScopedVector<int> own_property_count(length);
   int total_property_count = 0;
   {
     PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
-    for (; !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN);
-         iter.Advance()) {
+    for (int i = 0; i < length; i++) {
       DCHECK(!iter.IsAtEnd());
       Handle<JSObject> jsproto =
           Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
       // Only collect names if access is permitted.
       if (jsproto->IsAccessCheckNeeded() &&
           !isolate->MayNamedAccess(jsproto,
                                    isolate->factory()->undefined_value(),
                                    v8::ACCESS_KEYS)) {
         isolate->ReportFailedAccessCheck(jsproto, v8::ACCESS_KEYS);
         RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
         return *isolate->factory()->NewJSArray(0);
       }
       int n;
       n = jsproto->NumberOfOwnProperties(filter);
+      own_property_count[i] = n;
       total_property_count += n;
+      iter.Advance();
     }
   }
 
   // Allocate an array with storage for all the property names.
   Handle<FixedArray> names =
       isolate->factory()->NewFixedArray(total_property_count);
 
   // Get the property names.
   int next_copy_index = 0;
   int hidden_strings = 0;
   {
     PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
-    for (; !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN);
-         iter.Advance()) {
+    for (int i = 0; i < length; i++) {
+      DCHECK(!iter.IsAtEnd());
       Handle<JSObject> jsproto =
           Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
-      int own_property_count =
-          jsproto->GetOwnPropertyNames(*names, next_copy_index, filter);
-      if (!jsproto.is_identical_to(obj)) {
+      jsproto->GetOwnPropertyNames(*names, next_copy_index, filter);
+      if (i > 0) {
         // Names from hidden prototypes may already have been added
         // for inherited function template instances. Count the duplicates
         // and stub them out; the final copy pass at the end ignores holes.
-        for (int j = next_copy_index; j < next_copy_index + own_property_count;
-             j++) {
+        for (int j = next_copy_index;
+             j < next_copy_index + own_property_count[i]; j++) {
           Object* name_from_hidden_proto = names->get(j);
           for (int k = 0; k < next_copy_index; k++) {
             if (names->get(k) != isolate->heap()->hidden_string()) {
               Object* name = names->get(k);
               if (name_from_hidden_proto == name) {
                 names->set(j, isolate->heap()->hidden_string());
                 hidden_strings++;
                 break;
               }
             }
           }
         }
       }
-      next_copy_index += own_property_count;
+      next_copy_index += own_property_count[i];
 
       // Hidden properties only show up if the filter does not skip strings.
       if ((filter & STRING) == 0 && JSObject::HasHiddenProperties(jsproto)) {
         hidden_strings++;
       }
+      iter.Advance();
     }
   }
 
   // Filter out name of hidden properties object and
   // hidden prototype duplicates.
   if (hidden_strings > 0) {
     Handle<FixedArray> old_names = names;
     names = isolate->factory()->NewFixedArray(
         names->length() - hidden_strings);
     int dest_pos = 0;
@@ skipping 9813 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal