[d8] Fix tsan bugs

src/d8.h

 // 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.
 
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
 #ifndef V8_SHARED
 #include "src/allocation.h"
 #include "src/hashmap.h"
@@ skipping 101 matching lines @@
     begin_offset_ = offset;
   }
 
   void End(int offset) { end_offset_ = offset; }
 
   void Execute(Isolate* isolate);
 
 #ifndef V8_SHARED
   void StartExecuteInThread();
   void WaitForThread();
+  void JoinThread();
 
  private:
   class IsolateThread : public base::Thread {
    public:
     explicit IsolateThread(SourceGroup* group)
         : base::Thread(GetThreadOptions()), group_(group) {}
 
     virtual void Run() {
       group_->ExecuteInThread();
     }
@@ skipping 135 matching lines @@
   base::Atomic32 state_;
   base::Atomic32 join_called_;
 };
 #endif  // !V8_SHARED
 
 
 class ShellOptions {
  public:
   ShellOptions()
       : script_executed(false),
-        last_run(true),
         send_idle_notification(false),
         invoke_weak_callbacks(false),
         omit_quit(false),
         stress_opt(false),
         stress_deopt(false),
+        stress_runs(1),
         interactive_shell(false),
         test_shell(false),
         dump_heap_constants(false),
         expected_to_throw(false),
         mock_arraybuffer_allocator(false),
         num_isolates(1),
         compile_options(v8::ScriptCompiler::kNoCompileOptions),
         isolate_sources(NULL),
         icu_data_file(NULL),
         natives_blob(NULL),
         snapshot_blob(NULL) {}
 
   ~ShellOptions() {
     delete[] isolate_sources;
   }
 
   bool use_interactive_shell() {
     return (interactive_shell || !script_executed) && !test_shell;
   }
 
   bool script_executed;
-  bool last_run;
   bool send_idle_notification;
   bool invoke_weak_callbacks;
   bool omit_quit;
   bool stress_opt;
   bool stress_deopt;
+  int stress_runs;
   bool interactive_shell;
   bool test_shell;
   bool dump_heap_constants;
   bool expected_to_throw;
   bool mock_arraybuffer_allocator;
   int num_isolates;
   v8::ScriptCompiler::CompileOptions compile_options;
   SourceGroup* isolate_sources;
   const char* icu_data_file;
   const char* natives_blob;
@@ skipping 14 matching lines @@
       v8::ScriptCompiler::CompileOptions compile_options,
       SourceType source_type);
   static bool ExecuteString(Isolate* isolate, Local<String> source,
                             Local<Value> name, bool print_result,
                             bool report_exceptions,
                             SourceType source_type = SCRIPT);
   static const char* ToCString(const v8::String::Utf8Value& value);
   static void ReportException(Isolate* isolate, TryCatch* try_catch);
   static Local<String> ReadFile(Isolate* isolate, const char* name);
   static Local<Context> CreateEvaluationContext(Isolate* isolate);
-  static int RunMain(Isolate* isolate, int argc, char* argv[]);
+  static int RunMain(Isolate* isolate, int argc, char* argv[], bool last_run);
   static int Main(int argc, char* argv[]);
   static void Exit(int exit_code);
   static void OnExit(Isolate* isolate);
   static void CollectGarbage(Isolate* isolate);
   static void EmptyMessageQueues(Isolate* isolate);
 
 #ifndef V8_SHARED
   // TODO(binji): stupid implementation for now. Is there an easy way to hash an
   // object for use in i::HashMap? By pointer?
   typedef i::List<Local<Object>> ObjectList;
@@ skipping 113 matching lines @@
   static void RunShell(Isolate* isolate);
   static bool SetOptions(int argc, char* argv[]);
   static Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_