Transition array should not know about write barrier internals.

src/transitions.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 "src/transitions.h"
 
 #include "src/objects-inl.h"
 #include "src/transitions-inl.h"
 #include "src/utils.h"
 
@@ skipping 33 matching lines @@
         old_details.attributes() == new_details.attributes()) {
       Handle<WeakCell> cell = Map::WeakCellForMap(target);
       ReplaceTransitions(map, *cell);
       return;
     }
     // Otherwise allocate a full TransitionArray with slack for a new entry.
     Handle<TransitionArray> result = Allocate(isolate, 1, 1);
     // Re-read existing data; the allocation might have caused it to be cleared.
     if (IsSimpleTransition(map->raw_transitions())) {
       old_target = GetSimpleTransition(map->raw_transitions());
-      result->NoIncrementalWriteBarrierSet(
-          0, GetSimpleTransitionKey(old_target), old_target);
+      result->Set(0, GetSimpleTransitionKey(old_target), old_target);
     } else {
       result->SetNumberOfTransitions(0);
     }
     ReplaceTransitions(map, *result);
   }
 
   // At this point, we know that the map has a full TransitionArray.
   DCHECK(IsFullTransitionArray(map->raw_transitions()));
 
   int number_of_transitions = 0;
@@ skipping 72 matching lines @@
     result->Shrink(ToKeyIndex(new_nof));
     result->SetNumberOfTransitions(new_nof);
   }
 
   if (array->HasPrototypeTransitions()) {
     result->SetPrototypeTransitions(array->GetPrototypeTransitions());
   }
 
   DCHECK_NE(kNotFound, insertion_index);
   for (int i = 0; i < insertion_index; ++i) {
-    result->NoIncrementalWriteBarrierCopyFrom(array, i, i);
+    result->Set(i, array->GetKey(i), array->GetTarget(i));
   }
-  result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
+  result->Set(insertion_index, *name, *target);
   for (int i = insertion_index; i < number_of_transitions; ++i) {
-    result->NoIncrementalWriteBarrierCopyFrom(array, i, i + 1);
+    result->Set(i + 1, array->GetKey(i), array->GetTarget(i));
   }
 
   SLOW_DCHECK(result->IsSortedNoDuplicates());
   ReplaceTransitions(map, *result);
 }
 
 
 // static
 Map* TransitionArray::SearchTransition(Map* map, PropertyKind kind, Name* name,
                                        PropertyAttributes attributes) {
@@ skipping 230 matching lines @@
                                                   int number_of_transitions,
                                                   int slack) {
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(
       LengthFor(number_of_transitions + slack));
   array->set(kPrototypeTransitionsIndex, Smi::FromInt(0));
   array->set(kTransitionLengthIndex, Smi::FromInt(number_of_transitions));
   return Handle<TransitionArray>::cast(array);
 }
 
 
-void TransitionArray::NoIncrementalWriteBarrierCopyFrom(TransitionArray* origin,
-                                                        int origin_transition,
-                                                        int target_transition) {
-  NoIncrementalWriteBarrierSet(target_transition,
-                               origin->GetKey(origin_transition),
-                               origin->GetTarget(origin_transition));
-}
-
-
 static void ZapTransitionArray(TransitionArray* transitions) {
   MemsetPointer(transitions->data_start(),
                 transitions->GetHeap()->the_hole_value(),
                 transitions->length());
 }
 
 
 void TransitionArray::ReplaceTransitions(Handle<Map> map,
                                          Object* new_transitions) {
   Object* raw_transitions = map->raw_transitions();
@@ skipping 30 matching lines @@
   // Reload pointer after the allocation that just happened.
   raw_transitions = map->raw_transitions();
   int new_nof = IsSimpleTransition(raw_transitions) ? 1 : 0;
   if (new_nof != nof) {
     DCHECK(new_nof == 0);
     result->Shrink(ToKeyIndex(0));
     result->SetNumberOfTransitions(0);
   } else if (nof == 1) {
     Map* target = GetSimpleTransition(raw_transitions);
     Name* key = GetSimpleTransitionKey(target);
-    result->NoIncrementalWriteBarrierSet(0, key, target);
+    result->Set(0, key, target);
   }
   ReplaceTransitions(map, *result);
 }
 
 
 void TransitionArray::TraverseTransitionTreeInternal(Map* map,
                                                      TraverseCallback callback,
                                                      void* data) {
   Object* raw_transitions = map->raw_transitions();
   if (IsFullTransitionArray(raw_transitions)) {
@@ skipping 77 matching lines @@
                             PropertyAttributes attributes,
                             int* out_insertion_index) {
   int transition = SearchName(name, out_insertion_index);
   if (transition == kNotFound) {
     return kNotFound;
   }
   return SearchDetails(transition, kind, attributes, out_insertion_index);
 }
 }  // namespace internal
 }  // namespace v8