Fix race condition with HasMutatorThread that was being used without a lock.

runtime/vm/isolate.h

 // Copyright (c) 2013, 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_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 159 matching lines @@
     return OFFSET_OF(Isolate, ic_miss_code_);
   }
 
   Dart_MessageNotifyCallback message_notify_callback() const {
     return message_notify_callback_;
   }
   void set_message_notify_callback(Dart_MessageNotifyCallback value) {
     message_notify_callback_ = value;
   }
 
-  // Limited public access to BaseIsolate::mutator_thread_ for code that
-  // must treat the mutator as the default or a special case. Prefer code
-  // that works uniformly across all threads.
-  bool HasMutatorThread() {
-    return mutator_thread_ != NULL;
-  }
-  Thread* mutator_thread() const {
-    return mutator_thread_;

[Florian Schneider, 2016/07/28 18:13:36]

Can you remove mutator_thread_ in BaseIsolate? It seems unused now.

[siva, 2016/07/28 20:15:10]

The field is still used in EnterIsolate to ensure that we don't have multiple
mutator threads entering an Isolate (see Isolate::ScheduleThread). That check is
under a lock.

-  }
+  Thread* mutator_thread() const;
 
   const char* name() const { return name_; }
   const char* debugger_name() const { return debugger_name_; }
   void set_debugger_name(const char* name);
 
   int64_t start_time() const { return start_time_; }
 
   Dart_Port main_port() const { return main_port_; }
   void set_main_port(Dart_Port port) {
     ASSERT(main_port_ == 0);  // Only set main port once.
@@ skipping 260 matching lines @@
     ASSERT(defer_finalization_count_ >= 0);
     return defer_finalization_count_ == 0;
   }
 
 #ifndef PRODUCT
   void PrintJSON(JSONStream* stream, bool ref = true);
 #endif
 
   // Mutator thread is used to aggregate compiler stats.
   CompilerStats* aggregate_compiler_stats() {
-    ASSERT(HasMutatorThread());
-    return mutator_thread_->compiler_stats();
+    return mutator_thread()->compiler_stats();
   }
 
   VMTagCounters* vm_tag_counters() {
     return &vm_tag_counters_;
   }
 
   bool IsReloading() const {
     return reload_context_ != NULL;
   }
 
@@ skipping 205 matching lines @@
       const GrowableObjectArray& value);
 
   Monitor* threads_lock() const;
   Thread* ScheduleThread(bool is_mutator, bool bypass_safepoint = false);
   void UnscheduleThread(
       Thread* thread, bool is_mutator, bool bypass_safepoint = false);
 
   // DEPRECATED: Use Thread's methods instead. During migration, these default
   // to using the mutator thread (which must also be the current thread).
   Zone* current_zone() const {
-    ASSERT(Thread::Current() == mutator_thread_);
-    return mutator_thread_->zone();
+    ASSERT(Thread::Current() == mutator_thread());
+    return mutator_thread()->zone();
   }
 
   // Accessed from generated code:
   StoreBuffer* store_buffer_;
   Heap* heap_;
   uword user_tag_;
   RawUserTag* current_tag_;
   RawUserTag* default_tag_;
   RawCode* ic_miss_code_;
   ClassTable class_table_;
@@ skipping 286 matching lines @@
   intptr_t* spawn_count_;
 
   Dart_IsolateFlags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_