Fix lint issues.

src/runtime.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 4067 matching lines @@
 }
 
 
 /**
  * A helper function that visits elements of an Array object, and elements
  * on its prototypes.
  *
  * Elements on prototypes are visited first, and only elements whose indices
  * less than Array length are visited.
  *
- * If a ArrayConcatVisitor object is given, the visitor is called with 
+ * If a ArrayConcatVisitor object is given, the visitor is called with
  * parameters, element's index + visitor_index_offset and the element.
  */
 static uint32_t IterateArrayAndPrototypeElements(Handle<JSArray> array,
                                                  ArrayConcatVisitor* visitor) {
   uint32_t range = static_cast<uint32_t>(array->length()->Number());
   Handle<Object> obj = array;
 
   static const int kEstimatedPrototypes = 3;
   List< Handle<JSObject> > objects(kEstimatedPrototypes);
 
   // Visit prototype first. If an element on the prototype is shadowed by
   // the inheritor using the same index, the ArrayConcatVisitor visits
   // the prototype element before the shadowing element.
   // The visitor can simply overwrite the old value by new value using
   // the same index.  This follows Array::concat semantics.
-  while(!obj->IsNull()) {
+  while (!obj->IsNull()) {
     objects.Add(obj);
     obj = Handle<Object>(obj->GetPrototype());
   }
 
   uint32_t nof_elements = 0;
   for (int i = objects.length() - 1; i >= 0; i--) {
     Handle<JSObject> obj = objects[i];
     nof_elements +=
         IterateElements(Handle<JSObject>::cast(obj), range, visitor);
   }
 
-  return nof_elements; 
+  return nof_elements;
 }
 
 
 /**
  * A helper function of Runtime_ArrayConcat.
  *
  * The first argument is an Array of Arrays and objects. It is the same as
  * the arguments array of Array::concat JS function.
  *
  * If an argument is an Array object, the function visits array elements.
@@ skipping 17 matching lines @@
       // the array length number of elements.
       visited_elements += (nof_elements > len) ? len : nof_elements;
       if (visitor) visitor->increase_index_offset(len);
 
     } else {
       if (visitor) {
         visitor->visit(0, obj);
         visitor->increase_index_offset(1);
       }
       visited_elements++;
-    }       
+    }
   }
   return visited_elements;
 }
 
 
 /**
  * Array::concat implementation.
  * See ECMAScript 262, 15.4.4.4.
  */
 static Object* Runtime_ArrayConcat(Arguments args) {
@@ skipping 1589 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal