Named all zones in the project

test/unittests/compiler/zone-stats-unittest.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/zone-stats.h"
 #include "src/base/utils/random-number-generator.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 33 matching lines @@
 };
 
 TEST_F(ZoneStatsTest, Empty) {
   ExpectForPool(0, 0, 0);
   {
     ZoneStats::StatsScope stats(zone_stats());
     Expect(&stats, 0, 0, 0);
   }
   ExpectForPool(0, 0, 0);
   {
-    ZoneStats::Scope scope(zone_stats());
+    ZoneStats::Scope scope(zone_stats(), ZONE_NAME);
     scope.zone();
   }
   ExpectForPool(0, 0, 0);
 }
 
 TEST_F(ZoneStatsTest, MultipleZonesWithDeletion) {
   static const size_t kArraySize = 10;
 
   ZoneStats::Scope* scopes[kArraySize];
 
   // Initialize.
   size_t before_stats = 0;
   for (size_t i = 0; i < kArraySize; ++i) {
-    scopes[i] = new ZoneStats::Scope(zone_stats());
+    scopes[i] = new ZoneStats::Scope(zone_stats(), ZONE_NAME);
     before_stats += Allocate(scopes[i]->zone());  // Add some stuff.
   }
 
   ExpectForPool(before_stats, before_stats, before_stats);
 
   ZoneStats::StatsScope stats(zone_stats());
 
   size_t before_deletion = 0;
   for (size_t i = 0; i < kArraySize; ++i) {
     before_deletion += Allocate(scopes[i]->zone());  // Add some stuff.
   }
 
   Expect(&stats, before_deletion, before_deletion, before_deletion);
   ExpectForPool(before_stats + before_deletion, before_stats + before_deletion,
                 before_stats + before_deletion);
 
   // Delete the scopes and create new ones.
   for (size_t i = 0; i < kArraySize; ++i) {
     delete scopes[i];
-    scopes[i] = new ZoneStats::Scope(zone_stats());
+    scopes[i] = new ZoneStats::Scope(zone_stats(), ZONE_NAME);
   }
 
   Expect(&stats, 0, before_deletion, before_deletion);
   ExpectForPool(0, before_stats + before_deletion,
                 before_stats + before_deletion);
 
   size_t after_deletion = 0;
   for (size_t i = 0; i < kArraySize; ++i) {
     after_deletion += Allocate(scopes[i]->zone());  // Add some stuff.
   }
@@ skipping 14 matching lines @@
   ExpectForPool(0, std::max(after_deletion, before_stats + before_deletion),
                 before_stats + before_deletion + after_deletion);
 }
 
 TEST_F(ZoneStatsTest, SimpleAllocationLoop) {
   int runs = 20;
   size_t total_allocated = 0;
   size_t max_loop_allocation = 0;
   ZoneStats::StatsScope outer_stats(zone_stats());
   {
-    ZoneStats::Scope outer_scope(zone_stats());
+    ZoneStats::Scope outer_scope(zone_stats(), ZONE_NAME);
     size_t outer_allocated = 0;
     for (int i = 0; i < runs; ++i) {
       {
         size_t bytes = Allocate(outer_scope.zone());
         outer_allocated += bytes;
         total_allocated += bytes;
       }
       ZoneStats::StatsScope inner_stats(zone_stats());
       size_t allocated = 0;
       {
-        ZoneStats::Scope inner_scope(zone_stats());
+        ZoneStats::Scope inner_scope(zone_stats(), ZONE_NAME);
         for (int j = 0; j < 20; ++j) {
           size_t bytes = Allocate(inner_scope.zone());
           allocated += bytes;
           total_allocated += bytes;
           max_loop_allocation =
               std::max(max_loop_allocation, outer_allocated + allocated);
           Expect(&inner_stats, allocated, allocated, allocated);
           Expect(&outer_stats, outer_allocated + allocated, max_loop_allocation,
                  total_allocated);
           ExpectForPool(outer_allocated + allocated, max_loop_allocation,
                         total_allocated);
         }
       }
       Expect(&inner_stats, 0, allocated, allocated);
       Expect(&outer_stats, outer_allocated, max_loop_allocation,
              total_allocated);
       ExpectForPool(outer_allocated, max_loop_allocation, total_allocated);
     }
   }
   Expect(&outer_stats, 0, max_loop_allocation, total_allocated);
   ExpectForPool(0, max_loop_allocation, total_allocated);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8