[keys] Cleanup: removing unused parameters in elements.cc and keys.cc

src/keys.cc

 // Copyright 2013 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 "src/keys.h"
 
 #include "src/api-arguments.h"
 #include "src/elements.h"
 #include "src/factory.h"
 #include "src/identity-map.h"
@@ skipping 296 matching lines @@
   // Store the protoLength on the first call of this method.
   if (!elements_.empty()) {
     level_lengths_.push_back(level_string_length_);
     level_lengths_.push_back(level_symbol_length_);
   }
   elements_.push_back(new std::vector<uint32_t>());
   level_string_length_ = 0;
   level_symbol_length_ = 0;
 }
 
-Maybe<bool> KeyAccumulator::GetKeys_Internal(Handle<JSReceiver> receiver,
-                                             Handle<JSReceiver> object,
-                                             KeyCollectionType type) {
+Maybe<bool> KeyAccumulator::CollectKeys(Handle<JSReceiver> receiver,
+                                        Handle<JSReceiver> object) {
   // Proxies have no hidden prototype and we should not trigger the
   // [[GetPrototypeOf]] trap on the last iteration when using
   // AdvanceFollowingProxies.
-  if (type == OWN_ONLY && object->IsJSProxy()) {
-    MAYBE_RETURN(
-        JSProxyOwnPropertyKeys(receiver, Handle<JSProxy>::cast(object)),
-        Nothing<bool>());
+  if (type_ == OWN_ONLY && object->IsJSProxy()) {
+    MAYBE_RETURN(CollectOwnJSProxyKeys(receiver, Handle<JSProxy>::cast(object)),
+                 Nothing<bool>());
     return Just(true);
   }
 
-  PrototypeIterator::WhereToEnd end = type == OWN_ONLY
+  PrototypeIterator::WhereToEnd end = type_ == OWN_ONLY
                                           ? PrototypeIterator::END_AT_NON_HIDDEN
                                           : PrototypeIterator::END_AT_NULL;
   for (PrototypeIterator iter(isolate_, object,
                               PrototypeIterator::START_AT_RECEIVER, end);
        !iter.IsAtEnd();) {
     Handle<JSReceiver> current =
         PrototypeIterator::GetCurrent<JSReceiver>(iter);
     Maybe<bool> result = Just(false);  // Dummy initialization.
     if (current->IsJSProxy()) {
-      result = JSProxyOwnPropertyKeys(receiver, Handle<JSProxy>::cast(current));
+      result = CollectOwnJSProxyKeys(receiver, Handle<JSProxy>::cast(current));
     } else {
       DCHECK(current->IsJSObject());
-      result =
-          GetKeysFromJSObject(receiver, Handle<JSObject>::cast(current), type);
+      result = CollectOwnKeys(receiver, Handle<JSObject>::cast(current));
     }
     MAYBE_RETURN(result, Nothing<bool>());
     if (!result.FromJust()) break;  // |false| means "stop iterating".
     // Iterate through proxies but ignore access checks for the ALL_CAN_READ
-    // case on API objects for OWN_ONLY keys handled in GetKeysFromJSObject.
+    // case on API objects for OWN_ONLY keys handled in CollectOwnKeys.
     if (!iter.AdvanceFollowingProxiesIgnoringAccessChecks()) {
       return Nothing<bool>();
     }
   }
   return Just(true);
 }
 
 namespace {
 
 void TrySettingEmptyEnumCache(JSReceiver* object) {
@@ skipping 262 matching lines @@
   DCHECK(result->IsJSArray() || result->HasSloppyArgumentsElements());
   // The accumulator takes care of string/symbol filtering.
   if (type == kIndexed) {
     accumulator->AddElementKeysFromInterceptor(result);
   } else {
     accumulator->AddKeys(result, DO_NOT_CONVERT);
   }
   return Just(true);
 }
 
-void KeyAccumulator::CollectOwnElementKeys(Handle<JSObject> object) {
+void KeyAccumulator::CollectOwnElementIndices(Handle<JSObject> object) {
   if (filter_ & SKIP_STRINGS) return;
   ElementsAccessor* accessor = object->GetElementsAccessor();
-  accessor->CollectElementIndices(object, this, kMaxUInt32, filter_, 0);
+  accessor->CollectElementIndices(object, this);
 }
 
 void KeyAccumulator::CollectOwnPropertyNames(Handle<JSObject> object) {
   if (object->HasFastProperties()) {
     int real_size = object->map()->NumberOfOwnDescriptors();
     Handle<DescriptorArray> descs(object->map()->instance_descriptors(),
                                   isolate_);
     for (int i = 0; i < real_size; i++) {
       PropertyDetails details = descs->GetDetails(i);
       if ((details.attributes() & filter_) != 0) continue;
@@ skipping 11 matching lines @@
     GlobalDictionary::CollectKeysTo(
         handle(object->global_dictionary(), isolate_), this, filter_);
   } else {
     NameDictionary::CollectKeysTo(
         handle(object->property_dictionary(), isolate_), this, filter_);
   }
 }
 
 // Returns |true| on success, |false| if prototype walking should be stopped,
 // |nothing| if an exception was thrown.
-Maybe<bool> KeyAccumulator::GetKeysFromJSObject(Handle<JSReceiver> receiver,
-                                                Handle<JSObject> object,
-                                                KeyCollectionType type) {
+Maybe<bool> KeyAccumulator::CollectOwnKeys(Handle<JSReceiver> receiver,
+                                           Handle<JSObject> object) {
   this->NextPrototype();
   // Check access rights if required.
   if (object->IsAccessCheckNeeded() &&
       !isolate_->MayAccess(handle(isolate_->context()), object)) {
     // The cross-origin spec says that [[Enumerate]] shall return an empty
     // iterator when it doesn't have access...
-    if (type == INCLUDE_PROTOS) {
+    if (type_ == INCLUDE_PROTOS) {
       return Just(false);
     }
     // ...whereas [[OwnPropertyKeys]] shall return whitelisted properties.
-    DCHECK_EQ(OWN_ONLY, type);
+    DCHECK_EQ(OWN_ONLY, type_);
     filter_ = static_cast<PropertyFilter>(filter_ | ONLY_ALL_CAN_READ);
   }
 
-  this->CollectOwnElementKeys(object);
+  this->CollectOwnElementIndices(object);
 
   // Add the element keys from the interceptor.
   Maybe<bool> success =
       GetKeysFromInterceptor<v8::IndexedPropertyEnumeratorCallback, kIndexed>(
           receiver, object, this);
   MAYBE_RETURN(success, Nothing<bool>());
 
   if (filter_ == ENUMERABLE_STRINGS) {
     Handle<FixedArray> enum_keys =
         KeyAccumulator::GetEnumPropertyKeys(isolate_, object);
@@ skipping 30 matching lines @@
       return isolate->factory()->empty_fixed_array();
     }
     Handle<FixedArray> storage = isolate->factory()->NewFixedArray(length);
     dictionary->CopyEnumKeysTo(*storage);
     return storage;
   }
 }
 
 // ES6 9.5.12
 // Returns |true| on success, |nothing| in case of exception.
-Maybe<bool> KeyAccumulator::JSProxyOwnPropertyKeys(Handle<JSReceiver> receiver,
-                                                   Handle<JSProxy> proxy) {
+Maybe<bool> KeyAccumulator::CollectOwnJSProxyKeys(Handle<JSReceiver> receiver,
+                                                  Handle<JSProxy> proxy) {
   STACK_CHECK(isolate_, Nothing<bool>());
   // 1. Let handler be the value of the [[ProxyHandler]] internal slot of O.
   Handle<Object> handler(proxy->handler(), isolate_);
   // 2. If handler is null, throw a TypeError exception.
   // 3. Assert: Type(handler) is Object.
   if (proxy->IsRevoked()) {
     isolate_->Throw(*isolate_->factory()->NewTypeError(
         MessageTemplate::kProxyRevoked, isolate_->factory()->ownKeys_string()));
     return Nothing<bool>();
   }
   // 4. Let target be the value of the [[ProxyTarget]] internal slot of O.
   Handle<JSReceiver> target(proxy->target(), isolate_);
   // 5. Let trap be ? GetMethod(handler, "ownKeys").
   Handle<Object> trap;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate_, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
                                         isolate_->factory()->ownKeys_string()),
       Nothing<bool>());
   // 6. If trap is undefined, then
   if (trap->IsUndefined()) {
     // 6a. Return target.[[OwnPropertyKeys]]().
-    return this->GetKeys_Internal(receiver, target, OWN_ONLY);
+    KeyCollectionType previous_type = type_;
+    type_ = OWN_ONLY;
+    Maybe<bool> result = this->CollectKeys(receiver, target);
+    type_ = previous_type;
+    return result;
   }
   // 7. Let trapResultArray be Call(trap, handler, «target»).
   Handle<Object> trap_result_array;
   Handle<Object> args[] = {target};
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate_, trap_result_array,
       Execution::Call(isolate_, trap, handler, arraysize(args), args),
       Nothing<bool>());
   // 8. Let trapResult be ? CreateListFromArrayLike(trapResultArray,
   //    «String, Symbol»).
@@ skipping 104 matching lines @@
     isolate_->Throw(*isolate_->factory()->NewTypeError(
         MessageTemplate::kProxyOwnKeysNonExtensible));
     return Nothing<bool>();
   }
   // 21. Return trapResult.
   return this->AddKeysFromProxy(proxy, trap_result);
 }
 
 }  // namespace internal
 }  // namespace v8