Revert "[Object.observe] Don't force normalization of elements for observed objects"

src/objects.cc

 // Copyright 2013 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 5596 matching lines @@
   return object;
 }
 
 
 void JSObject::SetObserved(Handle<JSObject> object) {
   Isolate* isolate = object->GetIsolate();
 
   if (object->map()->is_observed())
     return;
 
+  if (!object->HasExternalArrayElements()) {
+    // Go to dictionary mode, so that we don't skip map checks.
+    NormalizeElements(object);
+    ASSERT(!object->HasFastElements());
+  }
+
   LookupResult result(isolate);
   object->map()->LookupTransition(*object,
                                   isolate->heap()->observed_symbol(),
                                   &result);
 
   Handle<Map> new_map;
   if (result.IsTransition()) {
     new_map = handle(result.GetTransitionTarget());
     ASSERT(new_map->is_observed());
   } else if (object->map()->CanHaveMoreTransitions()) {
     new_map = Map::CopyForObserved(handle(object->map()));
   } else {
     new_map = Map::Copy(handle(object->map()));
-    new_map->set_is_observed();
+    new_map->set_is_observed(true);
   }
   object->set_map(*new_map);
 }
 
 
 Handle<JSObject> JSObject::Copy(Handle<JSObject> object,
                                 Handle<AllocationSite> site) {
   Isolate* isolate = object->GetIsolate();
   CALL_HEAP_FUNCTION(isolate,
                      isolate->heap()->CopyJSObject(*object, *site), JSObject);
@@ skipping 1317 matching lines @@
   } else {
     new_map = Map::Copy(map);
   }
 
   Handle<TransitionArray> transitions =
       Map::AddTransition(map, isolate->factory()->observed_symbol(), new_map,
                          FULL_TRANSITION);
 
   map->set_transitions(*transitions);
 
-  new_map->set_is_observed();
+  new_map->set_is_observed(true);
 
   if (map->owns_descriptors()) {
     new_map->InitializeDescriptors(map->instance_descriptors());
     map->set_owns_descriptors(false);
   }
 
   new_map->SetBackPointer(*map);
   return new_map;
 }
 
@@ skipping 4234 matching lines @@
 #endif  // ENABLE_DISASSEMBLER
 
 
 MaybeObject* JSObject::SetFastElementsCapacityAndLength(
     int capacity,
     int length,
     SetFastElementsCapacitySmiMode smi_mode) {
   Heap* heap = GetHeap();
   // We should never end in here with a pixel or external array.
   ASSERT(!HasExternalArrayElements());
+  ASSERT(!map()->is_observed());
 
   // Allocate a new fast elements backing store.
   FixedArray* new_elements;
   MaybeObject* maybe = heap->AllocateUninitializedFixedArray(capacity);
   if (!maybe->To(&new_elements)) return maybe;
 
   ElementsKind elements_kind = GetElementsKind();
   ElementsKind new_elements_kind;
   // The resized array has FAST_*_SMI_ELEMENTS if the capacity mode forces it,
   // or if it's allowed and the old elements array contained only SMIs.
@@ skipping 64 matching lines @@
 
   return false;
 }
 
 MaybeObject* JSObject::SetFastDoubleElementsCapacityAndLength(
     int capacity,
     int length) {
   Heap* heap = GetHeap();
   // We should never end in here with a pixel or external array.
   ASSERT(!HasExternalArrayElements());
+  ASSERT(!map()->is_observed());
 
   FixedArrayBase* elems;
   { MaybeObject* maybe_obj =
         heap->AllocateUninitializedFixedDoubleArray(capacity);
     if (!maybe_obj->To(&elems)) return maybe_obj;
   }
 
   ElementsKind elements_kind = GetElementsKind();
   ElementsKind new_elements_kind = elements_kind;
   if (IsHoleyElementsKind(elements_kind)) {
@@ skipping 128 matching lines @@
   List<uint32_t> indices;
   List<Handle<Object> > old_values;
   Handle<Object> old_length_handle(self->length(), isolate);
   Handle<Object> new_length_handle(len, isolate);
   uint32_t old_length = 0;
   CHECK(old_length_handle->ToArrayIndex(&old_length));
   uint32_t new_length = 0;
   if (!new_length_handle->ToArrayIndex(&new_length))
     return Failure::InternalError();
 
+  // Observed arrays should always be in dictionary mode;
+  // if they were in fast mode, the below is slower than necessary
+  // as it iterates over the array backing store multiple times.
+  ASSERT(self->HasDictionaryElements());
   static const PropertyAttributes kNoAttrFilter = NONE;
   int num_elements = self->NumberOfLocalElements(kNoAttrFilter);
   if (num_elements > 0) {
     if (old_length == static_cast<uint32_t>(num_elements)) {
       // Simple case for arrays without holes.
       for (uint32_t i = old_length - 1; i + 1 > new_length; --i) {
         if (!GetOldValue(isolate, self, i, &old_values, &indices)) break;
       }
     } else {
       // For sparse arrays, only iterate over existing elements.
-      // TODO(rafaelw): For fast, sparse arrays, we can avoid iterating over
-      // the to-be-removed indices twice.
       Handle<FixedArray> keys = isolate->factory()->NewFixedArray(num_elements);
       self->GetLocalElementKeys(*keys, kNoAttrFilter);
       while (num_elements-- > 0) {
         uint32_t index = NumberToUint32(keys->get(num_elements));
         if (index < new_length) break;
         if (!GetOldValue(isolate, self, index, &old_values, &indices)) break;
       }
     }
   }
 
@@ skipping 1378 matching lines @@
                ElementsKindToString(to_kind));
       }
       site->set_transition_info(Smi::FromInt(to_kind));
     }
   }
   return this;
 }
 
 
 MaybeObject* JSObject::TransitionElementsKind(ElementsKind to_kind) {
+  ASSERT(!map()->is_observed());
   ElementsKind from_kind = map()->elements_kind();
 
   if (IsFastHoleyElementsKind(from_kind)) {
     to_kind = GetHoleyElementsKind(to_kind);
   }
 
   if (from_kind == to_kind) return this;
   // Don't update the site if to_kind isn't fast
   if (IsFastElementsKind(to_kind)) {
     MaybeObject* maybe_failure = UpdateAllocationSite(to_kind);
@@ skipping 3649 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal