IDL: Use Nullable for union type return value

Source/bindings/core/v8/Nullable.h

 // Copyright 2014 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.
 
 #ifndef Nullable_h
 #define Nullable_h
 
 #include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 template <typename T>
 class Nullable {
     DISALLOW_ALLOCATION();
 public:
     Nullable()
         : m_value()
         , m_isNull(true) { }
 
     Nullable(const T& value)

[haraken, 2014/08/13 13:07:10]

Probably add 'explicit' ?

[Jens Widell, 2014/08/13 13:11:08]

That would require changes to for instance
WebGLRenderingContextBase::getSupportedExtensions(), which now returns a
Vector<String> value directly in the non-null case but whose return type is
Nullable<Vector<String> >.

[haraken, 2014/08/13 13:12:54]

Makes sense.

         : m_value(value)
         , m_isNull(false) { }
 
     Nullable(const Nullable& other)
         : m_value(other.m_value)
         , m_isNull(other.m_isNull) { }
 
     Nullable& operator=(const Nullable& other)
     {
         m_value = other.m_value;
         m_isNull = other.m_isNull;
         return *this;
     }
 
+    void set(const T& value)
+    {
+        m_value = value;
+        m_isNull = false;
+    }
     const T& get() const { ASSERT(!m_isNull); return m_value; }
+    T& get() { ASSERT(!m_isNull); return m_value; }
     bool isNull() const { return m_isNull; }
 
     operator bool() const { return !m_isNull && m_value; }

[haraken, 2014/08/13 13:07:10]

In order to allow implicit conversion to bool but prevent implicit conversion to
other integer types, can we use the "UnspecifiedBoolType trick" in RefPtr.h?

[bashi, 2014/08/13 13:45:56]

Will do.

[bashi, 2014/08/15 02:43:53]

It turns out we need a meta-function or need to rely on SFINAE to make this
workable for *Ptr family. Since there is no call site at this point, I'd rather
remove this. We can re-add it when we need it.

 
     bool operator==(const Nullable& other) const
     {
         return (m_isNull && other.m_isNull) || (!m_isNull && !other.m_isNull && m_value == other.m_value);
     }
 
     void trace(Visitor* visitor)
     {
         TraceIfNeeded<T>::trace(visitor, &m_value);
     }
 
 private:
     T m_value;
     bool m_isNull;
 };
 
 } // namespace blink
 
 #endif // Nullable_h