diff --git a/src/global-handles.cc b/src/global-handles.cc
index c2194fc89b..46b7db322a 100644
--- a/src/global-handles.cc
+++ b/src/global-handles.cc
@@ -258,7 +258,7 @@ void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
 }
 
 
-void GlobalHandles::MarkWeakRoots(WeakSlotCallback f) {
+void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (Node* current = head_; current != NULL; current = current->next()) {
     if (current->state_ == Node::WEAK) {
       if (f(&current->object_)) {
diff --git a/src/global-handles.h b/src/global-handles.h
index c5f44503ba..e6e9de1d13 100644
--- a/src/global-handles.h
+++ b/src/global-handles.h
@@ -98,8 +98,9 @@ class GlobalHandles : public AllStatic {
   // Iterates over all weak roots in heap.
   static void IterateWeakRoots(ObjectVisitor* v);
 
-  // Mark the weak pointers based on the callback.
-  static void MarkWeakRoots(WeakSlotCallback f);
+  // Find all weak handles satisfying the callback predicate, mark
+  // them as pending.
+  static void IdentifyWeakHandles(WeakSlotCallback f);
 
   // Add an object group.
   // Should only used in GC callback function before a collection.
diff --git a/src/mark-compact.cc b/src/mark-compact.cc
index 94cf315a86..3685766db2 100644
--- a/src/mark-compact.cc
+++ b/src/mark-compact.cc
@@ -555,10 +555,8 @@ static void ScanOverflowedObjects(T* it) {
 }
 
 
-bool MarkCompactCollector::MustBeMarked(Object** p) {
-  // Check whether *p is a HeapObject pointer.
-  if (!(*p)->IsHeapObject()) return false;
-  return !HeapObject::cast(*p)->IsMarked();
+bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
+  return (*p)->IsHeapObject() && !HeapObject::cast(*p)->IsMarked();
 }
 
 
@@ -756,19 +754,20 @@ void MarkCompactCollector::MarkLiveObjects() {
   RootMarkingVisitor root_visitor;
   MarkRoots(&root_visitor);
 
-  // The objects reachable from the roots are marked black, unreachable
-  // objects are white.  Mark objects reachable from object groups with at
-  // least one marked object, and continue until no new objects are
-  // reachable from the object groups.
+  // The objects reachable from the roots are marked, yet unreachable
+  // objects are unmarked.  Mark objects reachable from object groups
+  // containing at least one marked object, and continue until no new
+  // objects are reachable from the object groups.
   ProcessObjectGroups(root_visitor.stack_visitor());
 
-  // The objects reachable from the roots or object groups are marked black,
-  // unreachable objects are white.  Process objects reachable only from
-  // weak global handles.
+  // The objects reachable from the roots or object groups are marked,
+  // yet unreachable objects are unmarked.  Mark objects reachable
+  // only from weak global handles.
   //
-  // First we mark weak pointers not yet reachable.
-  GlobalHandles::MarkWeakRoots(&MustBeMarked);
-  // Then we process weak pointers and process the transitive closure.
+  // First we identify nonlive weak handles and mark them as pending
+  // destruction.
+  GlobalHandles::IdentifyWeakHandles(&IsUnmarkedHeapObject);
+  // Then we mark the objects and process the transitive closure.
   GlobalHandles::IterateWeakRoots(&root_visitor);
   while (marking_stack.overflowed()) {
     RefillMarkingStack();
@@ -801,22 +800,21 @@ static int CountMarkedCallback(HeapObject* obj) {
 
 
 #ifdef DEBUG
-void MarkCompactCollector::UpdateLiveObjectCount(HeapObject* obj, int scale) {
-  ASSERT(scale == -1 || scale == 1);
-  live_bytes_ += obj->Size() * scale;
+void MarkCompactCollector::UpdateLiveObjectCount(HeapObject* obj) {
+  live_bytes_ += obj->Size();
   if (Heap::new_space()->Contains(obj)) {
-    live_young_objects_ += scale;
+    live_young_objects_++;
   } else if (Heap::map_space()->Contains(obj)) {
     ASSERT(obj->IsMap());
-    live_map_objects_ += scale;
+    live_map_objects_ ++;
   } else if (Heap::old_pointer_space()->Contains(obj)) {
-    live_old_pointer_objects_ += scale;
+    live_old_pointer_objects_++;
   } else if (Heap::old_data_space()->Contains(obj)) {
-    live_old_data_objects_ += scale;
+    live_old_data_objects_++;
   } else if (Heap::code_space()->Contains(obj)) {
-    live_code_objects_ += scale;
+    live_code_objects_++;
   } else if (Heap::lo_space()->Contains(obj)) {
-    live_lo_objects_ +=scale;
+    live_lo_objects_++;
   } else {
     UNREACHABLE();
   }
diff --git a/src/mark-compact.h b/src/mark-compact.h
index 432b8cc149..bfa2c3ce51 100644
--- a/src/mark-compact.h
+++ b/src/mark-compact.h
@@ -142,7 +142,6 @@ class MarkCompactCollector: public AllStatic {
 
   friend class RootMarkingVisitor;
   friend class MarkingVisitor;
-  friend class UnmarkingVisitor;
 
   // Marking operations for objects reachable from roots.
   static void MarkLiveObjects();
@@ -156,7 +155,7 @@ class MarkCompactCollector: public AllStatic {
   static inline void SetMark(HeapObject* obj) {
     tracer_->increment_marked_count();
 #ifdef DEBUG
-    UpdateLiveObjectCount(obj, 1);
+    UpdateLiveObjectCount(obj);
 #endif
     obj->SetMark();
   }
@@ -203,14 +202,12 @@ class MarkCompactCollector: public AllStatic {
   // flag on the marking stack.
   static void RefillMarkingStack();
 
-  // Callback function for telling whether the object *p must be marked.
-  static bool MustBeMarked(Object** p);
+  // Callback function for telling whether the object *p is an unmarked
+  // heap object.
+  static bool IsUnmarkedHeapObject(Object** p);
 
 #ifdef DEBUG
-  // The scale argument is positive 1 if we are marking an object and
-  // -1 if we are clearing the mark bit of an object that we didn't
-  // actually want marked.
-  static void UpdateLiveObjectCount(HeapObject* obj, int scale);
+  static void UpdateLiveObjectCount(HeapObject* obj);
 #endif
 
   // We sweep the large object space in the same way whether we are