Clean up issues raised on previous CL.

src/isolate.cc

 // Copyright 2012 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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 2270 matching lines @@
 };
 
 Isolate::Isolate(bool enable_serializer)
     : embedder_data_(),
       entry_stack_(NULL),
       stack_trace_nesting_level_(0),
       incomplete_message_(NULL),
       bootstrapper_(NULL),
       runtime_profiler_(NULL),
       compilation_cache_(NULL),
-      counters_(NULL),
       logger_(NULL),
       stats_table_(NULL),
       load_stub_cache_(NULL),
       store_stub_cache_(NULL),
       code_aging_helper_(NULL),
       deoptimizer_data_(NULL),
       deoptimizer_lazy_throw_(false),
       materialized_object_store_(NULL),
       capture_stack_trace_for_uncaught_exceptions_(false),
       stack_trace_for_uncaught_exceptions_frame_limit_(0),
@@ skipping 243 matching lines @@
   delete code_aging_helper_;
   code_aging_helper_ = NULL;
   stats_table_ = NULL;
 
   delete materialized_object_store_;
   materialized_object_store_ = NULL;
 
   delete logger_;
   logger_ = NULL;
 
-  counters_ = NULL;
-
   delete handle_scope_implementer_;
   handle_scope_implementer_ = NULL;
 
   delete code_tracer();
   set_code_tracer(NULL);
 
   delete compilation_cache_;
   compilation_cache_ = NULL;
   delete bootstrapper_;
   bootstrapper_ = NULL;
@@ skipping 63 matching lines @@
     handler->has_terminated_ = false;
     handler->exception_ = pending_exception();
     // Propagate to the external try-catch only if we got an actual message.
     if (thread_local_top_.pending_message_obj_->IsTheHole(this)) return true;
 
     handler->message_obj_ = thread_local_top_.pending_message_obj_;
   }
   return true;
 }
 
-static base::LazyMutex initialize_counters_mutex = LAZY_MUTEX_INITIALIZER;
-
 bool Isolate::InitializeCounters() {
-  if (counters_ != nullptr) return false;
-  base::LockGuard<base::Mutex> guard(initialize_counters_mutex.Pointer());
-  if (counters_ != nullptr) return false;
+  if (counters_shared_) return false;
   counters_shared_ = std::make_shared<Counters>(this);
-  counters_ = counters_shared_.get();
   return true;
 }
 
 void Isolate::InitializeLoggingAndCounters() {
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   InitializeCounters();
 }
 
@@ skipping 199 matching lines @@
 
   return true;
 }
 
 
 // Initialized lazily to allow early
 // v8::V8::SetAddHistogramSampleFunction calls.
 StatsTable* Isolate::stats_table() {
   if (stats_table_ != nullptr) return stats_table_;
   InitializeCounters();
-  return stats_table_ = counters_->stats_table();
+  stats_table_ = counters_shared_->stats_table();
+  return stats_table_;
 }
 
 
 void Isolate::Enter() {
   Isolate* current_isolate = NULL;
   PerIsolateThreadData* current_data = CurrentPerIsolateThreadData();
   if (current_data != NULL) {
     current_isolate = current_data->isolate_;
     DCHECK(current_isolate != NULL);
     if (current_isolate == this) {
@@ skipping 909 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8