Revert "The current growth strategy for growable arrays allocates a backing array of size 2 at (emp…

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 1357 matching lines @@
       // of the activation's current scope.
       if (!conflict) {
         param_names.Add(name);
         param_values.Add(value);
       }
     }
   }
 
   if (function().is_static()) {
     const Class& cls = Class::Handle(function().Owner());
-    return cls.Evaluate(expr,
-                        Array::Handle(Array::MakeFixedLength(param_names)),
-                        Array::Handle(Array::MakeFixedLength(param_values)));
+    return cls.Evaluate(expr, Array::Handle(Array::MakeArray(param_names)),
+                        Array::Handle(Array::MakeArray(param_values)));
   } else {
     const Object& receiver = Object::Handle(GetReceiver());
     const Class& method_cls = Class::Handle(function().origin());
     ASSERT(receiver.IsInstance() || receiver.IsNull());
     if (!(receiver.IsInstance() || receiver.IsNull())) {
       return Object::null();
     }
     const Instance& inst = Instance::Cast(receiver);
     return inst.Evaluate(method_cls, expr,
-                         Array::Handle(Array::MakeFixedLength(param_names)),
-                         Array::Handle(Array::MakeFixedLength(param_values)));
+                         Array::Handle(Array::MakeArray(param_names)),
+                         Array::Handle(Array::MakeArray(param_values)));
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 const char* ActivationFrame::ToCString() {
   const String& url = String::Handle(SourceUrl());
   intptr_t line = LineNumber();
   const char* func_name = Debugger::QualifiedFunctionName(function());
@@ skipping 1767 matching lines @@
       field ^= fields.At(i);
       if (!field.is_static()) {
         field_name = field.name();
         field_list.Add(field_name);
         field_value = GetInstanceField(cls, field_name, obj);
         field_list.Add(field_value);
       }
     }
     cls = cls.SuperClass();
   }
-  return Array::MakeFixedLength(field_list);
+  return Array::MakeArray(field_list);
 }
 
 
 RawArray* Debugger::GetStaticFields(const Class& cls) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   String& field_name = String::Handle();
   PassiveObject& field_value = PassiveObject::Handle();
   for (intptr_t i = 0; i < fields.Length(); i++) {
     field ^= fields.At(i);
     if (field.is_static()) {
       field_name = field.name();
       field_value = GetStaticField(cls, field_name);
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
-  return Array::MakeFixedLength(field_list);
+  return Array::MakeArray(field_list);
 }
 
 
 void Debugger::CollectLibraryFields(const GrowableObjectArray& field_list,
                                     const Library& lib,
                                     const String& prefix,
                                     bool include_private_fields) {
   DictionaryIterator it(lib);
   Zone* zone = Thread::Current()->zone();
   Object& entry = Object::Handle(zone);
@@ skipping 27 matching lines @@
     }
   }
 }
 
 
 RawArray* Debugger::GetLibraryFields(const Library& lib) {
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   CollectLibraryFields(field_list, lib, String::Handle(zone), true);
-  return Array::MakeFixedLength(field_list);
+  return Array::MakeArray(field_list);
 }
 
 
 RawArray* Debugger::GetGlobalFields(const Library& lib) {
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(zone, GrowableObjectArray::New(8));
   String& prefix_name = String::Handle(zone);
   CollectLibraryFields(field_list, lib, prefix_name, true);
   Library& imported = Library::Handle(zone);
   intptr_t num_imports = lib.num_imports();
   for (intptr_t i = 0; i < num_imports; i++) {
     imported = lib.ImportLibraryAt(i);
     ASSERT(!imported.IsNull());
     CollectLibraryFields(field_list, imported, prefix_name, false);
   }
   LibraryPrefix& prefix = LibraryPrefix::Handle(zone);
   LibraryPrefixIterator it(lib);
   while (it.HasNext()) {
     prefix = it.GetNext();
     prefix_name = prefix.name();
     ASSERT(!prefix_name.IsNull());
     prefix_name = String::Concat(prefix_name, Symbols::Dot());
     for (int32_t i = 0; i < prefix.num_imports(); i++) {
       imported = prefix.GetLibrary(i);
       CollectLibraryFields(field_list, imported, prefix_name, false);
     }
   }
-  return Array::MakeFixedLength(field_list);
+  return Array::MakeArray(field_list);
 }
 
 
 // static
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
   BreakpointLocation* bpt = breakpoint_locations_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
@@ skipping 1242 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart