Re-land: gin: Use V8 Maybe APIs

gin/converter.cc

 // Copyright 2013 The Chromium 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 "gin/converter.h"
 
 #include "v8/include/v8.h"
 
 using v8::ArrayBuffer;
 using v8::Boolean;
 using v8::External;
 using v8::Function;
+using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
+using v8::Maybe;
+using v8::MaybeLocal;
 using v8::Number;
 using v8::Object;
 using v8::String;
+using v8::Uint32;
 using v8::Value;
 
+namespace {
+
+template <typename T, typename U>
+bool FromMaybe(Maybe<T> maybe, U* out) {
+  if (maybe.IsNothing())
+    return false;
+  *out = static_cast<U>(maybe.FromJust());
+  return true;
+}
+
+}  // namespace
+
 namespace gin {
 
 Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
   return Boolean::New(isolate, val).As<Value>();
 }
 
 bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) {
-  *out = val->BooleanValue();
-  return true;
+  return FromMaybe(val->BooleanValue(isolate->GetCurrentContext()), out);
 }
 
 Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
   return Integer::New(isolate, val).As<Value>();
 }
 
 bool Converter<int32_t>::FromV8(Isolate* isolate,
                                 Local<Value> val,
                                 int32_t* out) {
   if (!val->IsInt32())
     return false;
-  *out = val->Int32Value();
+  *out = val.As<Int32>()->Value();
   return true;
 }
 
 Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
   return Integer::NewFromUnsigned(isolate, val).As<Value>();
 }
 
 bool Converter<uint32_t>::FromV8(Isolate* isolate,
                                  Local<Value> val,
                                  uint32_t* out) {
   if (!val->IsUint32())
     return false;
-  *out = val->Uint32Value();
+  *out = val.As<Uint32>()->Value();
   return true;
 }
 
 Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
   return Number::New(isolate, static_cast<double>(val)).As<Value>();
 }
 
 bool Converter<int64_t>::FromV8(Isolate* isolate,
                                 Local<Value> val,
                                 int64_t* out) {
   if (!val->IsNumber())
     return false;
   // Even though IntegerValue returns int64_t, JavaScript cannot represent
   // the full precision of int64_t, which means some rounding might occur.
-  *out = val->IntegerValue();
-  return true;
+  return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out);
 }
 
 Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
   return Number::New(isolate, static_cast<double>(val)).As<Value>();
 }
 
 bool Converter<uint64_t>::FromV8(Isolate* isolate,
                                  Local<Value> val,
                                  uint64_t* out) {
   if (!val->IsNumber())
     return false;
-  *out = static_cast<uint64_t>(val->IntegerValue());
-  return true;
+  return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out);
 }
 
 Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) {
   return Number::New(isolate, val).As<Value>();
 }
 
 bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) {
   if (!val->IsNumber())
     return false;
-  *out = static_cast<float>(val->NumberValue());
+  *out = static_cast<float>(val.As<Number>()->Value());
   return true;
 }
 
 Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
   return Number::New(isolate, val).As<Value>();
 }
 
 bool Converter<double>::FromV8(Isolate* isolate,
                                Local<Value> val,
                                double* out) {
   if (!val->IsNumber())
     return false;
-  *out = val->NumberValue();
+  *out = val.As<Number>()->Value();
   return true;
 }
 
 Local<Value> Converter<base::StringPiece>::ToV8(Isolate* isolate,
                                                 const base::StringPiece& val) {
-  return String::NewFromUtf8(isolate, val.data(), String::kNormalString,
-                             static_cast<uint32_t>(val.length()));
+  return String::NewFromUtf8(isolate, val.data(),
+                             v8::NewStringType::kNormal,
+                             static_cast<uint32_t>(val.length()))
+      .ToLocalChecked();
 }
 
 Local<Value> Converter<std::string>::ToV8(Isolate* isolate,
                                           const std::string& val) {
   return Converter<base::StringPiece>::ToV8(isolate, val);
 }
 
 bool Converter<std::string>::FromV8(Isolate* isolate,
                                     Local<Value> val,
                                     std::string* out) {
@@ skipping 63 matching lines @@
 
 bool Converter<Local<Value>>::FromV8(Isolate* isolate,
                                      Local<Value> val,
                                      Local<Value>* out) {
   *out = val;
   return true;
 }
 
 v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                       const base::StringPiece& val) {
-  return String::NewFromUtf8(isolate,
-                             val.data(),
-                             String::kInternalizedString,
-                             static_cast<uint32_t>(val.length()));
+  return String::NewFromUtf8(isolate, val.data(),
+                             v8::NewStringType::kInternalized,
+                             static_cast<uint32_t>(val.length()))
+      .ToLocalChecked();
 }
 
 std::string V8ToString(v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return std::string();
   std::string result;
   if (!ConvertFromV8(NULL, value, &result))
     return std::string();
   return result;
 }
 
 }  // namespace gin