Fix a bunch of spelling mistakes :\

src/objects.cc

 // Copyright 2006-2008 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 1929 matching lines @@
     } else {
       int byte_array_length = ByteArray::LengthFor(instance_size_delta);
       int byte_array_length_offset = new_instance_size + kPointerSize;
       WRITE_FIELD(this, new_instance_size, Heap::byte_array_map());
       WRITE_INT_FIELD(this, byte_array_length_offset, byte_array_length);
     }
     WRITE_BARRIER(this, new_instance_size);
   }
   new_map->set_unused_property_fields(0);
 
-  // We have now sucessfully allocated all the necessary objects.
+  // We have now successfully allocated all the necessary objects.
   // Changes can now be made with the guarantee that all of them take effect.
   set_map(new_map);
   map()->set_instance_descriptors(Heap::empty_descriptor_array());
 
   set_properties(dictionary);
 
   Counters::props_to_dictionary.Increment();
 
 #ifdef DEBUG
   if (FLAG_trace_normalization) {
@@ skipping 456 matching lines @@
   name->TryFlatten(StringShape(name));
 
   // Make sure name is not an index.
   uint32_t index;
   if (name->AsArrayIndex(&index)) return Heap::undefined_value();
 
   // Check if there is an API defined callback object which prohibits
   // callback overwriting in this object or it's prototype chain.
   // This mechanism is needed for instance in a browser setting, where
   // certain accessors such as window.location should not be allowed
-  // to be overwriten because allowing overwriting could potentially
+  // to be overwritten because allowing overwriting could potentially
   // cause security problems.
   LookupResult callback_result;
   LookupCallback(name, &callback_result);
   if (callback_result.IsValid()) {
     Object* obj = callback_result.GetCallbackObject();
     if (obj->IsAccessorInfo() &&
         AccessorInfo::cast(obj)->prohibits_overwriting()) {
       return Heap::undefined_value();
     }
   }
@@ skipping 4577 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal