- Remove the unvisited handles code from handles implementation as it is not

runtime/vm/handles.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_HANDLES_H_
 #define VM_HANDLES_H_
 
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/os.h"
@@ skipping 59 matching lines @@
   }
 };
 
 
 template <int kHandleSizeInWords, int kHandlesPerChunk, int kOffsetOfRawPtr>
 class Handles {
  public:
   Handles()
       : zone_blocks_(NULL),
         first_scoped_block_(NULL),
-        scoped_blocks_(&first_scoped_block_),
-        last_visited_block_(NULL) {
+        scoped_blocks_(&first_scoped_block_) {
   }
   ~Handles() {
     DeleteAll();
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   // Visit all the scoped handles.
   void VisitScopedHandles(ObjectPointerVisitor* visitor);
@@ skipping 40 matching lines @@
  private:
   // Base structure for managing blocks of handles.
   // Handles are allocated in Chunks (each chunk holds kHandlesPerChunk
   // handles). The chunk is uninitialized, subsequent requests for handles
   // is allocated from the chunk until we run out space in the chunk,
   // at this point another chunk is allocated. These chunks are chained
   // together.
   class HandlesBlock {
    public:
     explicit HandlesBlock(HandlesBlock* next)
-        : last_visited_handle_(0),
-          next_handle_slot_(0),
+        : next_handle_slot_(0),
           next_block_(next) { }
     ~HandlesBlock();
 
     // Reinitializes handle block for reuse.
     void ReInit();
 
     // Returns true if the handle block is full.
     bool IsFull() const {
       return next_handle_slot_ >= (kHandleSizeInWords * kHandlesPerChunk);
     }
 
     // Returns true if passed in handle belongs to this block.
     bool IsValidHandle(uword handle) const {
       uword start = reinterpret_cast<uword>(data_);
       uword end = start + (kHandleSizeInWords * kWordSize * kHandlesPerChunk);
       return (start <= handle && handle < end);
     }
 
     // Allocates space for a handle in the data area.
     uword AllocateHandle() {
       ASSERT(!IsFull());
       uword handle_address = reinterpret_cast<uword>(data_ + next_handle_slot_);
       next_handle_slot_ += kHandleSizeInWords;
       return handle_address;
     }
 
     // Visit all object pointers in the handle block.
     void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
-    // Visit all the object pointers in the block since the last time this
-    // method was called.
-    void VisitUnvisitedObjectPointers(ObjectPointerVisitor* visitor);
-
     // Visit all of the handles in the handle block.
     void Visit(HandleVisitor* visitor);
 
 #if defined(DEBUG)
     // Zaps the free handle area to an uninitialized value.
     void ZapFreeHandles();
 #endif
 
     // Returns number of active handles in the handle block.
     int HandleCount() const;
 
     // Accessors.
     intptr_t next_handle_slot() const { return next_handle_slot_; }
     void set_next_handle_slot(intptr_t next_handle_slot) {
       next_handle_slot_ = next_handle_slot;
     }
     HandlesBlock* next_block() const { return next_block_; }
     void set_next_block(HandlesBlock* next) { next_block_ = next; }
 
    private:
-    // Last handle visited by VisitUnvisitedObjectPointers.  Handles
-    // at, or beyond this index are new.
-    intptr_t last_visited_handle_;
-
     uword data_[kHandleSizeInWords * kHandlesPerChunk];  // Handles area.
     intptr_t next_handle_slot_;  // Next slot for allocation in current block.
     HandlesBlock* next_block_;  // Link to next block of handles.
 
     DISALLOW_COPY_AND_ASSIGN(HandlesBlock);
   };
 
   // Deletes all the allocated handle blocks.
   void DeleteAll();
   void DeleteHandleBlocks(HandlesBlock* blocks);
@@ skipping 16 matching lines @@
   // Verifies consistency of handle blocks after a scope is destroyed.
   void VerifyScopedHandleState();
 
   // Zaps the free scoped handles to an uninitialized value.
   void ZapFreeScopedHandles();
 #endif
 
   HandlesBlock* zone_blocks_;  // List of zone handles.
   HandlesBlock first_scoped_block_;  // First block of scoped handles.
   HandlesBlock* scoped_blocks_;  // List of scoped handles.
-  // Last block visited by VisitUnvisitedHandles.
-  HandlesBlock* last_visited_block_;
 
   friend class HandleScope;
   friend class Dart;
   friend class ObjectStore;
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Handles);
 };
 
 
 static const int kVMHandleSizeInWords = 2;
@@ skipping 100 matching lines @@
 };
 #endif  // defined(DEBUG)
 
 // Macro to start a no handles scope in the code.
 #define NOHANDLESCOPE(isolate)                                                \
     dart::NoHandleScope no_vm_internal_handles_scope_(isolate);
 
 }  // namespace dart
 
 #endif  // VM_HANDLES_H_