Fixed lol SetProperty() calls to specify the needed strict mode.

src/liveobjectlist.cc

 // Copyright 2011 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 574 matching lines @@
     GenerateObjectDesc(obj, buffer, sizeof(buffer));
     desc_str = buffer;
     size = obj->Size();
   }
   desc = Factory::NewStringFromAscii(CStrVector(desc_str));
   if (desc->IsFailure()) {
     error = desc;
     return false;
   }
 
-  { MaybeObject* maybe_result =
-          detail->SetProperty(*id_sym, Smi::FromInt(obj_id), NONE);
+  { MaybeObject* maybe_result = detail->SetProperty(*id_sym,
+                                                    Smi::FromInt(obj_id),
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return false;
   }
-  { MaybeObject* maybe_result =
-          detail->SetProperty(*desc_sym, *desc, NONE);
+  { MaybeObject* maybe_result = detail->SetProperty(*desc_sym,
+                                                    *desc,
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return false;
   }
-  { MaybeObject* maybe_result =
-          detail->SetProperty(*size_sym, Smi::FromInt(size), NONE);
+  { MaybeObject* maybe_result = detail->SetProperty(*size_sym,
+                                                    Smi::FromInt(size),
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return false;
   }
 
   arr->set(index, *detail);
   return true;
 }
 
 
 class DumpWriter {
  public:
@@ skipping 518 matching lines @@
 #endif
   }
 
   Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
   Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
   Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
 
   Handle<JSObject> result = Factory::NewJSObject(Top::object_function());
   if (result->IsFailure()) return Object::cast(*result);
 
-  { MaybeObject* maybe_result =
-          result->SetProperty(*id_sym, Smi::FromInt(lol->id()), NONE);
+  { MaybeObject* maybe_result = result->SetProperty(*id_sym,
+                                                    Smi::FromInt(lol->id()),
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
-  { MaybeObject* maybe_result =
-          result->SetProperty(*count_sym, Smi::FromInt(total_count), NONE);
+  { MaybeObject* maybe_result = result->SetProperty(*count_sym,
+                                                    Smi::FromInt(total_count),
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
-  { MaybeObject* maybe_result =
-          result->SetProperty(*size_sym, Smi::FromInt(size), NONE);
+  { MaybeObject* maybe_result = result->SetProperty(*size_sym,
+                                                    Smi::FromInt(size),
+                                                    NONE,
+                                                    kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
 
   return *result;
 }
 
 
 // Delete doesn't actually deletes an lol.  It just marks it as invisible since
 // its contents are considered to be part of subsequent lists as well.  The
 // only time we'll actually delete the lol is when we Reset() or if the lol is
@@ skipping 115 matching lines @@
   if (!success) return Object::cast(*error);
 
   MaybeObject* maybe_result;
 
   // Allocate the result body.
   Handle<JSObject> body = Factory::NewJSObject(Top::object_function());
   if (body->IsFailure()) return Object::cast(*body);
 
   // Set the updated body.count.
   Handle<String> count_sym = Factory::LookupAsciiSymbol("count");
-  maybe_result = body->SetProperty(*count_sym, Smi::FromInt(count), NONE);
+  maybe_result = body->SetProperty(*count_sym,
+                                   Smi::FromInt(count),
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   // Set the updated body.size if appropriate.
   if (size >= 0) {
     Handle<String> size_sym = Factory::LookupAsciiSymbol("size");
-    maybe_result = body->SetProperty(*size_sym, Smi::FromInt(size), NONE);
+    maybe_result = body->SetProperty(*size_sym,
+                                     Smi::FromInt(size),
+                                     NONE,
+                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
 
   // Set body.first_index.
   Handle<String> first_sym = Factory::LookupAsciiSymbol("first_index");
-  maybe_result = body->SetProperty(*first_sym, Smi::FromInt(start), NONE);
+  maybe_result = body->SetProperty(*first_sym,
+                                   Smi::FromInt(start),
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   // Allocate the JSArray of the elements.
   Handle<JSObject> elements = Factory::NewJSObject(Top::array_function());
   if (elements->IsFailure()) return Object::cast(*elements);
   Handle<JSArray>::cast(elements)->SetContent(*elements_arr);
 
   // Set body.elements.
   Handle<String> elements_sym = Factory::LookupAsciiSymbol("elements");
-  maybe_result = body->SetProperty(*elements_sym, *elements, NONE);
+  maybe_result = body->SetProperty(*elements_sym,
+                                   *elements,
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *body;
 }
 
 
 MaybeObject* LiveObjectList::Summarize(int older_id,
                                        int newer_id,
                                        Handle<JSObject> filter_obj) {
   if ((older_id < 0) || (newer_id < 0) || (last() == NULL)) {
@@ skipping 71 matching lines @@
     if (detail->IsFailure()) return Object::cast(*detail);
 
     // Fill in the summary record.
     LiveObjectType type = static_cast<LiveObjectType>(i);
     int count = summary.Count(type);
     if (count) {
       const char* desc_cstr = GetObjectTypeDesc(type);
       Handle<String> desc = Factory::LookupAsciiSymbol(desc_cstr);
       int size = summary.Size(type);
 
-      maybe_result = detail->SetProperty(*desc_sym, *desc, NONE);
+      maybe_result = detail->SetProperty(*desc_sym,
+                                         *desc,
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
-      maybe_result = detail->SetProperty(*count_sym, Smi::FromInt(count), NONE);
+      maybe_result = detail->SetProperty(*count_sym,
+                                         Smi::FromInt(count),
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
-      maybe_result = detail->SetProperty(*size_sym, Smi::FromInt(size), NONE);
+      maybe_result = detail->SetProperty(*size_sym,
+                                         Smi::FromInt(size),
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
 
       summary_arr->set(idx++, *detail);
     }
   }
 
   // Wrap the summary fixed array in a JS array.
   Handle<JSObject> summary_obj = Factory::NewJSObject(Top::array_function());
   if (summary_obj->IsFailure()) return Object::cast(*summary_obj);
   Handle<JSArray>::cast(summary_obj)->SetContent(*summary_arr);
 
   // Create the body object.
   Handle<JSObject> body = Factory::NewJSObject(Top::object_function());
   if (body->IsFailure()) return Object::cast(*body);
 
   // Fill out the body object.
   int total_count = summary.total_count();
   int total_size = summary.total_size();
-  maybe_result =
-      body->SetProperty(*count_sym, Smi::FromInt(total_count), NONE);
+  maybe_result = body->SetProperty(*count_sym,
+                                   Smi::FromInt(total_count),
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
-  maybe_result = body->SetProperty(*size_sym, Smi::FromInt(total_size), NONE);
+  maybe_result = body->SetProperty(*size_sym,
+                                   Smi::FromInt(total_size),
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   if (is_tracking_roots) {
     int found_root = summary.found_root();
     int found_weak_root = summary.found_weak_root();
     Handle<String> root_sym = Factory::LookupAsciiSymbol("found_root");
     Handle<String> weak_root_sym =
         Factory::LookupAsciiSymbol("found_weak_root");
-    maybe_result =
-        body->SetProperty(*root_sym, Smi::FromInt(found_root), NONE);
+    maybe_result = body->SetProperty(*root_sym,
+                                     Smi::FromInt(found_root),
+                                     NONE,
+                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
-    maybe_result =
-        body->SetProperty(*weak_root_sym, Smi::FromInt(found_weak_root), NONE);
+    maybe_result = body->SetProperty(*weak_root_sym,
+                                     Smi::FromInt(found_weak_root),
+                                     NONE,
+                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
   }
 
-  maybe_result = body->SetProperty(*summary_sym, *summary_obj, NONE);
+  maybe_result = body->SetProperty(*summary_sym,
+                                   *summary_obj,
+                                   NONE,
+                                   kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *body;
 }
 
 
 // Returns an array listing the captured lols.
 // Note: only dumps the section starting at start_idx and only up to
 // dump_limit entries.
 MaybeObject* LiveObjectList::Info(int start_idx, int dump_limit) {
@@ skipping 37 matching lines @@
   idx = 0;
   while ((lol != NULL) && (dump_limit != 0)) {
     if (lol->id() != 0) {
       int count;
       int size;
       count = lol->GetTotalObjCountAndSize(&size);
 
       Handle<JSObject> detail = Factory::NewJSObject(Top::object_function());
       if (detail->IsFailure()) return Object::cast(*detail);
 
-      maybe_result =
-          detail->SetProperty(*id_sym, Smi::FromInt(lol->id()), NONE);
+      maybe_result = detail->SetProperty(*id_sym,
+                                         Smi::FromInt(lol->id()),
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
-      maybe_result =
-          detail->SetProperty(*count_sym, Smi::FromInt(count), NONE);
+      maybe_result = detail->SetProperty(*count_sym,
+                                         Smi::FromInt(count),
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
-      maybe_result = detail->SetProperty(*size_sym, Smi::FromInt(size), NONE);
+      maybe_result = detail->SetProperty(*size_sym,
+                                         Smi::FromInt(size),
+                                         NONE,
+                                         kNonStrictMode);
       if (maybe_result->IsFailure()) return maybe_result;
       list->set(idx++, *detail);
       dump_limit--;
     }
     lol = lol->next();
   }
 
   // Return the result as a JS array.
   Handle<JSObject> lols = Factory::NewJSObject(Top::array_function());
   Handle<JSArray>::cast(lols)->SetContent(*list);
 
   Handle<JSObject> result = Factory::NewJSObject(Top::object_function());
   if (result->IsFailure()) return Object::cast(*result);
 
-  maybe_result =
-      result->SetProperty(*count_sym, Smi::FromInt(total_count), NONE);
+  maybe_result = result->SetProperty(*count_sym,
+                                     Smi::FromInt(total_count),
+                                     NONE,
+                                     kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   Handle<String> first_sym = Factory::LookupAsciiSymbol("first_index");
-  maybe_result =
-      result->SetProperty(*first_sym, Smi::FromInt(start_idx), NONE);
+  maybe_result = result->SetProperty(*first_sym,
+                                     Smi::FromInt(start_idx),
+                                     NONE,
+                                     kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   Handle<String> lists_sym = Factory::LookupAsciiSymbol("lists");
-  maybe_result = result->SetProperty(*lists_sym, *lols, NONE);
+  maybe_result = result->SetProperty(*lists_sym,
+                                     *lols,
+                                     NONE,
+                                     kNonStrictMode);
   if (maybe_result->IsFailure()) return maybe_result;
 
   return *result;
 }
 
 
 // Deletes all captured lols.
 void LiveObjectList::Reset() {
   LiveObjectList *lol = last();
   // Just delete the last.  Each lol will delete it's prev automatically.
@@ skipping 327 matching lines @@
     Object* body_obj;
     MaybeObject* maybe_result =
         DumpPrivate(&writer, start, dump_limit, &filter);
     if (!maybe_result->ToObject(&body_obj)) {
       return maybe_result;
     }
 
     // Set body.id.
     Handle<JSObject> body = Handle<JSObject>(JSObject::cast(body_obj));
     Handle<String> id_sym = Factory::LookupAsciiSymbol("id");
-    maybe_result = body->SetProperty(*id_sym, Smi::FromInt(obj_id), NONE);
+    maybe_result = body->SetProperty(*id_sym,
+                                     Smi::FromInt(obj_id),
+                                     NONE,
+                                     kNonStrictMode);
     if (maybe_result->IsFailure()) return maybe_result;
 
     return *body;
   }
 }
 
 
 Object* LiveObjectList::PrintObj(int obj_id) {
   Object* obj = GetObj(obj_id);
   if (!obj) {
@@ skipping 624 matching lines @@
     }
   }
 }
 #endif  // VERIFY_LOL
 
 
 } }  // namespace v8::internal
 
 #endif  // LIVE_OBJECT_LIST