Update all callsites of the TryCatch ctor to pass an Isolate

test/cctest/test-parsing.cc

 // Copyright 2012 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 1667 matching lines @@
 }
 
 
 TEST(StrictOctal) {
   // Test that syntax error caused by octal literal is reported correctly as
   // such (issue 2220).
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(
       v8::Context::New(CcTest::isolate()));
-  v8::TryCatch try_catch;
+  v8::TryCatch try_catch(CcTest::isolate());
   const char* script =
       "\"use strict\";       \n"
       "a = function() {      \n"
       "  b = function() {    \n"
       "    01;               \n"
       "  };                  \n"
       "};                    \n";
   v8::Script::Compile(v8::String::NewFromUtf8(CcTest::isolate(), script));
   CHECK(try_catch.HasCaught());
   v8::String::Utf8Value exception(try_catch.Exception());
@@ skipping 4518 matching lines @@
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }
 
 
 TEST(StrongModeFreeVariablesDeclaredByPreviousScript) {
   i::FLAG_strong_mode = true;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(v8::Context::New(CcTest::isolate()));
-  v8::TryCatch try_catch;
+  v8::TryCatch try_catch(CcTest::isolate());
 
   // Introduce a bunch of variables, in all language modes.
   const char* script1 =
       "var my_var1 = 0;        \n"
       "function my_func1() { } \n"
       "const my_const1 = 0;    \n";
   CompileRun(v8_str(script1));
   CHECK(!try_catch.HasCaught());
 
   const char* script2 =
@@ skipping 38 matching lines @@
   CompileRun(v8_str(script5));
   CHECK(!try_catch.HasCaught());
 }
 
 
 TEST(StrongModeFreeVariablesDeclaredByLanguage) {
   i::FLAG_strong_mode = true;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(v8::Context::New(CcTest::isolate()));
-  v8::TryCatch try_catch;
+  v8::TryCatch try_catch(CcTest::isolate());
 
   const char* script1 =
       "\"use strong\";         \n"
       "Math;                   \n"
       "RegExp;                 \n";
   CompileRun(v8_str(script1));
   CHECK(!try_catch.HasCaught());
 }
 
 
 TEST(StrongModeFreeVariablesDeclaredInGlobalPrototype) {
   i::FLAG_strong_mode = true;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(v8::Context::New(CcTest::isolate()));
-  v8::TryCatch try_catch;
+  v8::TryCatch try_catch(CcTest::isolate());
 
   const char* script1 = "this.__proto__.my_var = 0;\n";
   CompileRun(v8_str(script1));
   CHECK(!try_catch.HasCaught());
 
   const char* script2 =
       "\"use strong\";         \n"
       "my_var;                 \n";
   CompileRun(v8_str(script2));
   CHECK(!try_catch.HasCaught());
 }
 
 
 TEST(StrongModeFreeVariablesNotDeclared) {
   i::FLAG_strong_mode = true;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   v8::Context::Scope context_scope(v8::Context::New(CcTest::isolate()));
-  v8::TryCatch try_catch;
+  v8::TryCatch try_catch(CcTest::isolate());
 
   // Test that referencing unintroduced variables in sloppy mode is ok.
   const char* script1 =
       "if (false) {            \n"
       "  not_there1;           \n"
       "}                       \n";
   CompileRun(v8_str(script1));
   CHECK(!try_catch.HasCaught());
 
   // But not in strong mode.
   {
     const char* script2 =
         "\"use strong\";         \n"
         "if (false) {            \n"
         "  not_there2;           \n"
         "}                       \n";
-    v8::TryCatch try_catch2;
+    v8::TryCatch try_catch2(CcTest::isolate());
     v8::Script::Compile(v8_str(script2));
     CHECK(try_catch2.HasCaught());
     v8::String::Utf8Value exception(try_catch2.Exception());
     CHECK_EQ(0,
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there2' is not allowed",
                  *exception));
   }
 
   // Check that the variable reference is detected inside a strong function too,
   // even if the script scope is not strong.
   {
     const char* script3 =
         "(function not_lazy() {  \n"
         "  \"use strong\";       \n"
         "  if (false) {          \n"
         "    not_there3;         \n"
         "  }                     \n"
         "})();                   \n";
-    v8::TryCatch try_catch2;
+    v8::TryCatch try_catch2(CcTest::isolate());
     v8::Script::Compile(v8_str(script3));
     CHECK(try_catch2.HasCaught());
     v8::String::Utf8Value exception(try_catch2.Exception());
     CHECK_EQ(0,
              strcmp(
                  "ReferenceError: In strong mode, using an undeclared global "
                  "variable 'not_there3' is not allowed",
                  *exception));
   }
 }
@@ skipping 231 matching lines @@
     "[a, ...]",
     "[..., ]",
     "[..., ...]",
     "[ (...a)]",
     NULL};
   // clang-format on
   static const ParserFlag always_flags[] = {kAllowHarmonySpreadArrays};
   RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
                     arraysize(always_flags));
 }