Refactoring using TempAssign.

src/serialize.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 915 matching lines @@
 
 
 void Serializer::Finalize(char** str, int* len) {
   writer_->GetString(str, len);
 }
 
 
 // Serialize objects by writing them into the stream.
 
 void Serializer::VisitPointers(Object** start, Object** end) {
-  bool root = root_;
-  root_ = false;
+  TempAssign<bool> temp_root(&root_, false);
   for (Object** p = start; p < end; ++p) {
     bool serialized;
     Address a = Encode(*p, &serialized);
-    if (root) {
+    if (temp_root.old_value()) {
       roots_++;
       // If the object was not just serialized,
       // write its encoded address instead.
       if (!serialized) PutEncodedAddress(a);
     }
   }
-  root_ = root;
 }
 
 
 class GlobalHandlesRetriever: public ObjectVisitor {
  public:
   explicit GlobalHandlesRetriever(List<Object**>* handles)
   : global_handles_(handles) {}
 
   virtual void VisitPointers(Object** start, Object** end) {
     for (; start != end; ++start) {
@@ skipping 270 matching lines @@
   reference_decoder_ = new ExternalReferenceDecoder();
   // By setting linear allocation only, we forbid the use of free list
   // allocation which is not predicted by SimulatedAddress.
   GetHeader();
   Heap::IterateRoots(this);
   GetContextStack();
 }
 
 
 void Deserializer::VisitPointers(Object** start, Object** end) {
-  bool root = root_;
-  root_ = false;
+  TempAssign<bool> temp_root(&root_, false);
   for (Object** p = start; p < end; ++p) {
-    if (root) {
+    if (temp_root.old_value()) {
       roots_++;
       // Read the next object or pointer from the stream
       // pointer in the stream.
       int c = reader_.GetC();
       if (c == '[') {
         *p = GetObject();  // embedded object
       } else {
         ASSERT(c == 'P');  // pointer to previously serialized object
         *p = Resolve(reinterpret_cast<Address>(reader_.GetInt()));
       }
     } else {
       // A pointer internal to a HeapObject that we've already
       // read: resolve it to a true address (or Smi)
       *p = Resolve(reinterpret_cast<Address>(*p));
     }
   }
-  root_ = root;
 }
 
 
 void Deserializer::VisitExternalReferences(Address* start, Address* end) {
   for (Address* p = start; p < end; ++p) {
     uint32_t code = reinterpret_cast<uint32_t>(*p);
     *p = reference_decoder_->Decode(code);
   }
 }
 
@@ skipping 245 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal