Convert v8::Value::To* to use MaybeLocal

include/v8.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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 88 matching lines @@
 class String;
 class StringObject;
 class Symbol;
 class SymbolObject;
 class Private;
 class Uint32;
 class Utils;
 class Value;
 template <class T> class Handle;
 template <class T> class Local;
+template <class T>
+class MaybeLocal;
 template <class T> class Eternal;
 template<class T> class NonCopyablePersistentTraits;
 template<class T> class PersistentBase;
 template<class T,
          class M = NonCopyablePersistentTraits<T> > class Persistent;
 template<class T> class UniquePersistent;
 template<class K, class V, class T> class PersistentValueMap;
 template <class K, class V, class T>
 class PersistentValueMapBase;
 template <class K, class V, class T>
@@ skipping 196 matching lines @@
                                  const PersistentBase<T>& that) {
     return New(isolate, that.val_);
   }
 
  private:
   friend class Utils;
   template<class F, class M> friend class Persistent;
   template<class F> friend class PersistentBase;
   template<class F> friend class Handle;
   template<class F> friend class Local;
+  template <class F>
+  friend class MaybeLocal;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
   template<class F> friend class internal::CustomArguments;
   friend Handle<Primitive> Undefined(Isolate* isolate);
   friend Handle<Primitive> Null(Isolate* isolate);
   friend Handle<Boolean> True(Isolate* isolate);
   friend Handle<Boolean> False(Isolate* isolate);
   friend class Context;
   friend class HandleScope;
   friend class Object;
@@ skipping 57 matching lines @@
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that);
 
  private:
   friend class Utils;
   template<class F> friend class Eternal;
   template<class F> friend class PersistentBase;
   template<class F, class M> friend class Persistent;
   template<class F> friend class Handle;
   template<class F> friend class Local;
+  template <class F>
+  friend class MaybeLocal;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
   friend class String;
   friend class Object;
   friend class Context;
   template<class F> friend class internal::CustomArguments;
   friend class HandleScope;
   friend class EscapableHandleScope;
   template <class F1, class F2, class F3>
   friend class PersistentValueMapBase;
   template<class F1, class F2> friend class PersistentValueVector;
 
   template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
   V8_INLINE static Local<T> New(Isolate* isolate, T* that);
 };
 
 
+template <class T>
+class MaybeLocal {
+ public:
+  V8_INLINE MaybeLocal() : val_(nullptr) {}
+  template <class S>
+  V8_INLINE MaybeLocal(Local<S> that)
+      : val_(reinterpret_cast<T*>(*that)) {
+    TYPE_CHECK(T, S);
+  }
+
+  V8_INLINE bool IsEmpty() { return val_ == nullptr; }
+
+  template <class S>
+  V8_INLINE bool ToLocal(Local<S>* out) const {

[jochen (gone - plz use gerrit), 2015/02/27 09:42:49]

can we mark this as must use result?

[dcarney, 2015/02/27 09:49:50]

Done.

+    if (val_ == NULL) {
+      out->val_ = nullptr;
+      return false;
+    } else {
+      out->val_ = this->val_;
+      return true;
+    }
+  }
+
+  V8_INLINE Local<T> ToLocalChecked() {
+    // TODO(dcarney): add DCHECK.
+    return Local<T>(val_);
+  }
+
+ private:
+  T* val_;
+};
+
+
 // Eternal handles are set-once handles that live for the life of the isolate.
 template <class T> class Eternal {
  public:
   V8_INLINE Eternal() : index_(kInitialValue) { }
   template<class S>
   V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialValue) {
     Set(isolate, handle);
   }
   // Can only be safely called if already set.
   V8_INLINE Local<T> Get(Isolate* isolate);
@@ skipping 1411 matching lines @@
    * This is an experimental feature.
    */
   bool IsFloat64Array() const;
 
   /**
    * Returns true if this value is a DataView.
    * This is an experimental feature.
    */
   bool IsDataView() const;
 
+  MaybeLocal<Boolean> ToBoolean(Local<Context> context) const;
+  MaybeLocal<Number> ToNumber(Local<Context> context) const;
+  MaybeLocal<String> ToString(Local<Context> context) const;
+  MaybeLocal<String> ToDetailString(Local<Context> context) const;
+  MaybeLocal<Object> ToObject(Local<Context> context) const;
+  MaybeLocal<Integer> ToInteger(Local<Context> context) const;
+  MaybeLocal<Uint32> ToUint32(Local<Context> context) const;
+  MaybeLocal<Int32> ToInt32(Local<Context> context) const;
+
+  // TODO(dcarney): deprecate all these.
   Local<Boolean> ToBoolean(Isolate* isolate) const;
   Local<Number> ToNumber(Isolate* isolate) const;
   Local<String> ToString(Isolate* isolate) const;
   Local<String> ToDetailString(Isolate* isolate) const;
   Local<Object> ToObject(Isolate* isolate) const;
   Local<Integer> ToInteger(Isolate* isolate) const;
   Local<Uint32> ToUint32(Isolate* isolate) const;
   Local<Int32> ToInt32(Isolate* isolate) const;
 
-  // TODO(dcarney): deprecate all these.
+  // TODO(dcarney): deprecate all these as well.
   inline Local<Boolean> ToBoolean() const;
   inline Local<Number> ToNumber() const;
   inline Local<String> ToString() const;
   inline Local<String> ToDetailString() const;
   inline Local<Object> ToObject() const;
   inline Local<Integer> ToInteger() const;
   inline Local<Uint32> ToUint32() const;
   inline Local<Int32> ToInt32() const;
 
   /**
@@ skipping 5686 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_