Re-adjust access failure log messages for %GetOwnProperty.

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 984 matching lines @@
     if (current->IsAccessCheckNeeded() &&
         !(isolate->*mayAccess)(current, key, access_type)) {
       return false;
     }
     if (current == holder) break;
   }
   return true;
 }
 
 
-static bool CheckElementAccess(
+enum AccessCheckResult {
+  ACCESS_FORBIDDEN,
+  ACCESS_ALLOWED,
+  ACCESS_ABSENT
+};
+
+
+static AccessCheckResult CheckElementAccess(
     JSObject* obj,
     uint32_t index,
     v8::AccessType access_type) {
   // TODO(1095): we should traverse hidden prototype hierachy as well.
   if (CheckGenericAccess(
           obj, obj, index, access_type, &Isolate::MayIndexedAccess)) {
-    return true;
+    return ACCESS_ALLOWED;
   }
 
   obj->GetIsolate()->ReportFailedAccessCheck(obj, access_type);
-  return false;
+  return ACCESS_FORBIDDEN;
 }
 
 
-static bool CheckPropertyAccess(
+static AccessCheckResult CheckPropertyAccess(
     JSObject* obj,
     String* name,
     v8::AccessType access_type) {
   uint32_t index;
   if (name->AsArrayIndex(&index)) {
     return CheckElementAccess(obj, index, access_type);
   }
 
   LookupResult lookup(obj->GetIsolate());
   obj->LocalLookup(name, &lookup);
 
+  if (!lookup.IsProperty()) return ACCESS_ABSENT;
   if (CheckGenericAccess<Object*>(
           obj, lookup.holder(), name, access_type, &Isolate::MayNamedAccess)) {
-    return true;
+    return ACCESS_ALLOWED;
   }
 
   // Access check callback denied the access, but some properties
   // can have a special permissions which override callbacks descision
   // (currently see v8::AccessControl).
   // API callbacks can have per callback access exceptions.
   switch (lookup.type()) {
     case CALLBACKS:
       if (CheckAccessException(lookup.GetCallbackObject(), access_type)) {
-        return true;
+        return ACCESS_ALLOWED;
       }
       break;
     case INTERCEPTOR:
       // If the object has an interceptor, try real named properties.
       // Overwrite the result to fetch the correct property later.
       lookup.holder()->LookupRealNamedProperty(name, &lookup);
       if (lookup.IsProperty() && lookup.IsPropertyCallbacks()) {
         if (CheckAccessException(lookup.GetCallbackObject(), access_type)) {
-          return true;
+          return ACCESS_ALLOWED;
         }
       }
       break;
     default:
       break;
   }
 
   obj->GetIsolate()->ReportFailedAccessCheck(obj, access_type);
-  return false;
+  return ACCESS_FORBIDDEN;
 }
 
 
 // Enumerator used as indices into the array returned from GetOwnProperty
 enum PropertyDescriptorIndices {
   IS_ACCESSOR_INDEX,
   VALUE_INDEX,
   GETTER_INDEX,
   SETTER_INDEX,
   WRITABLE_INDEX,
   ENUMERABLE_INDEX,
   CONFIGURABLE_INDEX,
   DESCRIPTOR_SIZE
 };
 
 
 static MaybeObject* GetOwnProperty(Isolate* isolate,
                                    Handle<JSObject> obj,
                                    Handle<String> name) {
   Heap* heap = isolate->heap();
+  // Due to some WebKit tests, we want to make sure that we do not log
+  // more than one access failure here.
+  switch (CheckPropertyAccess(*obj, *name, v8::ACCESS_HAS)) {
+    case ACCESS_FORBIDDEN: return heap->false_value();
+    case ACCESS_ALLOWED: break;
+    case ACCESS_ABSENT: return heap->undefined_value();
+  }
+
   PropertyAttributes attrs = obj->GetLocalPropertyAttribute(*name);
   if (attrs == ABSENT) return heap->undefined_value();
   AccessorPair* accessors = obj->GetLocalPropertyAccessorPair(*name);
 
   Handle<FixedArray> elms = isolate->factory()->NewFixedArray(DESCRIPTOR_SIZE);
   elms->set(ENUMERABLE_INDEX, heap->ToBoolean((attrs & DONT_ENUM) == 0));
   elms->set(CONFIGURABLE_INDEX, heap->ToBoolean((attrs & DONT_DELETE) == 0));
   elms->set(IS_ACCESSOR_INDEX, heap->ToBoolean(accessors != NULL));
 
   if (accessors == NULL) {
@@ skipping 12208 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal