Remove deprecated APIs from two more tests

test/cctest/test-log.cc

 // Copyright 2006-2009 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Tests of logging functions from log.h
 
+// TODO(jochen): Remove this after the setting is turned on globally.
+#define V8_IMMINENT_DEPRECATION_WARNINGS
+
 #ifdef __linux__
 #include <pthread.h>
 #include <signal.h>
 #include <unistd.h>
 #include <cmath>
 #endif  // __linux__
 
 #include "src/v8.h"
 
 #include "src/log.h"
@@ skipping 38 matching lines @@
   }
 
   ~ScopedLoggerInitializer() {
     env_->Exit();
     logger_->TearDown();
     if (temp_file_ != NULL) fclose(temp_file_);
     i::FLAG_prof = saved_prof_;
     i::FLAG_log = saved_log_;
   }
 
-  v8::Handle<v8::Context>& env() { return env_; }
+  v8::Local<v8::Context>& env() { return env_; }
 
   v8::Isolate* isolate() { return isolate_; }
 
   Logger* logger() { return logger_; }
 
   FILE* StopLoggingGetTempFile() {
     temp_file_ = logger_->TearDown();
     CHECK(temp_file_);
     fflush(temp_file_);
     rewind(temp_file_);
     return temp_file_;
   }
 
  private:
   const bool saved_log_;
   const bool saved_prof_;
   FILE* temp_file_;
   v8::Isolate* isolate_;
   v8::Isolate::Scope isolate_scope_;
   v8::HandleScope scope_;
-  v8::Handle<v8::Context> env_;
+  v8::Local<v8::Context> env_;
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedLoggerInitializer);
 };
 
 }  // namespace
 
 
 static const char* StrNStr(const char* s1, const char* s2, int n) {
   if (s1[n] == '\0') return strstr(s1, s2);
@@ skipping 180 matching lines @@
   virtual size_t length() const { return utf_source_.length(); }
   virtual const uint16_t* data() const { return utf_source_.start(); }
  private:
   i::ScopedVector<uint16_t> utf_source_;
 };
 
 }  // namespace
 
 TEST(Issue23768) {
   v8::HandleScope scope(CcTest::isolate());
-  v8::Handle<v8::Context> env = v8::Context::New(CcTest::isolate());
+  v8::Local<v8::Context> env = v8::Context::New(CcTest::isolate());
   env->Enter();
 
   SimpleExternalString source_ext_str("(function ext() {})();");
   v8::Local<v8::String> source =
-      v8::String::NewExternal(CcTest::isolate(), &source_ext_str);
+      v8::String::NewExternalTwoByte(CcTest::isolate(), &source_ext_str)
+          .ToLocalChecked();
   // Script needs to have a name in order to trigger InitLineEnds execution.
-  v8::Handle<v8::String> origin =
-      v8::String::NewFromUtf8(CcTest::isolate(), "issue-23768-test");
-  v8::Handle<v8::Script> evil_script = CompileWithOrigin(source, origin);
+  v8::Local<v8::String> origin =
+      v8::String::NewFromUtf8(CcTest::isolate(), "issue-23768-test",
+                              v8::NewStringType::kNormal)
+          .ToLocalChecked();
+  v8::Local<v8::Script> evil_script = CompileWithOrigin(source, origin);
   CHECK(!evil_script.IsEmpty());
-  CHECK(!evil_script->Run().IsEmpty());
+  CHECK(!evil_script->Run(env).IsEmpty());
   i::Handle<i::ExternalTwoByteString> i_source(
       i::ExternalTwoByteString::cast(*v8::Utils::OpenHandle(*source)));
   // This situation can happen if source was an external string disposed
   // by its owner.
   i_source->set_resource(NULL);
 
   // Must not crash.
   CcTest::i_isolate()->logger()->LogCompiledFunctions();
 }
 
 
 static void ObjMethod1(const v8::FunctionCallbackInfo<v8::Value>& args) {
 }
 
 
 TEST(LogCallbacks) {
   SETUP_FLAGS();
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   {
     ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
     Logger* logger = initialize_logger.logger();
 
     v8::Local<v8::FunctionTemplate> obj = v8::Local<v8::FunctionTemplate>::New(
         isolate, v8::FunctionTemplate::New(isolate));
     obj->SetClassName(v8_str("Obj"));
-    v8::Handle<v8::ObjectTemplate> proto = obj->PrototypeTemplate();
+    v8::Local<v8::ObjectTemplate> proto = obj->PrototypeTemplate();
     v8::Local<v8::Signature> signature = v8::Signature::New(isolate, obj);
     proto->Set(v8_str("method1"),
                v8::FunctionTemplate::New(isolate, ObjMethod1,
-                                         v8::Handle<v8::Value>(), signature),
+                                         v8::Local<v8::Value>(), signature),
                static_cast<v8::PropertyAttribute>(v8::DontDelete));
 
-    initialize_logger.env()->Global()->Set(v8_str("Obj"), obj->GetFunction());
+    initialize_logger.env()
+        ->Global()
+        ->Set(initialize_logger.env(), v8_str("Obj"),
+              obj->GetFunction(initialize_logger.env()).ToLocalChecked())
+        .FromJust();
     CompileRun("Obj.prototype.method1.toString();");
 
     logger->LogCompiledFunctions();
 
     bool exists = false;
     i::Vector<const char> log(
         i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
     CHECK(exists);
 
     i::EmbeddedVector<char, 100> ref_data;
@@ skipping 27 matching lines @@
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   {
     ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
     Logger* logger = initialize_logger.logger();
 
     v8::Local<v8::FunctionTemplate> obj = v8::Local<v8::FunctionTemplate>::New(
         isolate, v8::FunctionTemplate::New(isolate));
     obj->SetClassName(v8_str("Obj"));
-    v8::Handle<v8::ObjectTemplate> inst = obj->InstanceTemplate();
+    v8::Local<v8::ObjectTemplate> inst = obj->InstanceTemplate();
     inst->SetAccessor(v8_str("prop1"), Prop1Getter, Prop1Setter);
     inst->SetAccessor(v8_str("prop2"), Prop2Getter);
 
     logger->LogAccessorCallbacks();
 
     bool exists = false;
     i::Vector<const char> log(
         i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
     CHECK(exists);
 
@@ skipping 53 matching lines @@
     logger->StringEvent("test-logging-done", "");
 
     // Iterate heap to find compiled functions, will write to log.
     logger->LogCompiledFunctions();
     logger->StringEvent("test-traversal-done", "");
 
     bool exists = false;
     i::Vector<const char> log(
         i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
     CHECK(exists);
-    v8::Handle<v8::String> log_str = v8::String::NewFromUtf8(
-        isolate, log.start(), v8::String::kNormalString, log.length());
-    initialize_logger.env()->Global()->Set(v8_str("_log"), log_str);
+    v8::Local<v8::String> log_str =
+        v8::String::NewFromUtf8(isolate, log.start(),
+                                v8::NewStringType::kNormal, log.length())
+            .ToLocalChecked();
+    initialize_logger.env()
+        ->Global()
+        ->Set(initialize_logger.env(), v8_str("_log"), log_str)
+        .FromJust();
 
     i::Vector<const char> source = TestSources::GetScriptsSource();
-    v8::Handle<v8::String> source_str = v8::String::NewFromUtf8(
-        isolate, source.start(), v8::String::kNormalString, source.length());
+    v8::Local<v8::String> source_str =
+        v8::String::NewFromUtf8(isolate, source.start(),
+                                v8::NewStringType::kNormal, source.length())
+            .ToLocalChecked();
     v8::TryCatch try_catch(isolate);
-    v8::Handle<v8::Script> script = CompileWithOrigin(source_str, "");
+    v8::Local<v8::Script> script = CompileWithOrigin(source_str, "");
     if (script.IsEmpty()) {
       v8::String::Utf8Value exception(try_catch.Exception());
       printf("compile: %s\n", *exception);
       CHECK(false);
     }
-    v8::Handle<v8::Value> result = script->Run();
-    if (result.IsEmpty()) {
+    v8::Local<v8::Value> result;
+    if (!script->Run(initialize_logger.env()).ToLocal(&result)) {
       v8::String::Utf8Value exception(try_catch.Exception());
       printf("run: %s\n", *exception);
       CHECK(false);
     }
     // The result either be a "true" literal or problem description.
     if (!result->IsTrue()) {
-      v8::Local<v8::String> s = result->ToString(isolate);
+      v8::Local<v8::String> s =
+          result->ToString(initialize_logger.env()).ToLocalChecked();
       i::ScopedVector<char> data(s->Utf8Length() + 1);
       CHECK(data.start());
       s->WriteUtf8(data.start());
       printf("%s\n", data.start());
       // Make sure that our output is written prior crash due to CHECK failure.
       fflush(stdout);
       CHECK(false);
     }
   }
   isolate->Dispose();
@@ skipping 68 matching lines @@
         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"
         "(){})();";
 
     CompileRun(source_text);
 
     // Must not crash.
     logger->LogCompiledFunctions();
   }
   isolate->Dispose();
 }