bindings: Adjust usage of CORE_EXPORT in IDLTypes and NativeValueTraits

third_party/WebKit/Source/bindings/core/v8/NativeValueTraitsImpl.h

 // Copyright (c) 2017 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 NativeValueTraitsImpl_h
 #define NativeValueTraitsImpl_h
 
 #include "bindings/core/v8/IDLTypes.h"
 #include "bindings/core/v8/NativeValueTraits.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/CoreExport.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 // Boolean
 template <>
-struct NativeValueTraits<IDLBoolean>
+struct CORE_EXPORT NativeValueTraits<IDLBoolean>
     : public NativeValueTraitsBase<IDLBoolean> {
-  CORE_EXPORT static inline bool nativeValue(v8::Isolate* isolate,
-                                             v8::Local<v8::Value> value,
-                                             ExceptionState& exceptionState) {
+  static inline bool nativeValue(v8::Isolate* isolate,
+                                 v8::Local<v8::Value> value,
+                                 ExceptionState& exceptionState) {
     return toBoolean(isolate, value, exceptionState);
   }
 };
 
 // Integers
 //
 // All integer specializations offer a second nativeValue() besides the default
 // one: it takes an IntegerConversionConfiguration argument to let callers
 // specify how the integers should be converted. The default nativeValue()
 // overload will always use NormalConversion.
 template <>
-struct NativeValueTraits<IDLByte> : public NativeValueTraitsBase<IDLByte> {
-  CORE_EXPORT static inline int8_t nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLByte>
+    : public NativeValueTraitsBase<IDLByte> {
+  static inline int8_t nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline int8_t nativeValue(
+  static inline int8_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toInt8(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLOctet> : public NativeValueTraitsBase<IDLOctet> {
-  CORE_EXPORT static inline uint8_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLOctet>
+    : public NativeValueTraitsBase<IDLOctet> {
+  static inline uint8_t nativeValue(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> value,
+                                    ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline uint8_t nativeValue(
+  static inline uint8_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toUInt8(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLShort> : public NativeValueTraitsBase<IDLShort> {
-  CORE_EXPORT static inline int16_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLShort>
+    : public NativeValueTraitsBase<IDLShort> {
+  static inline int16_t nativeValue(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> value,
+                                    ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline int16_t nativeValue(
+  static inline int16_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toInt16(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUnsignedShort>
+struct CORE_EXPORT NativeValueTraits<IDLUnsignedShort>
     : public NativeValueTraitsBase<IDLUnsignedShort> {
-  CORE_EXPORT static inline uint16_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline uint16_t nativeValue(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> value,
+                                     ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline uint16_t nativeValue(
+  static inline uint16_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toUInt16(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLLong> : public NativeValueTraitsBase<IDLLong> {
-  CORE_EXPORT static inline int32_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLLong>
+    : public NativeValueTraitsBase<IDLLong> {
+  static inline int32_t nativeValue(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> value,
+                                    ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline int32_t nativeValue(
+  static inline int32_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toInt32(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUnsignedLong>
+struct CORE_EXPORT NativeValueTraits<IDLUnsignedLong>
     : public NativeValueTraitsBase<IDLUnsignedLong> {
-  CORE_EXPORT static inline uint32_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline uint32_t nativeValue(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> value,
+                                     ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline uint32_t nativeValue(
+  static inline uint32_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toUInt32(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLLongLong>
+struct CORE_EXPORT NativeValueTraits<IDLLongLong>
     : public NativeValueTraitsBase<IDLLongLong> {
-  CORE_EXPORT static inline int64_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline int64_t nativeValue(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> value,
+                                    ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline int64_t nativeValue(
+  static inline int64_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toInt64(isolate, value, conversionMode, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUnsignedLongLong>
+struct CORE_EXPORT NativeValueTraits<IDLUnsignedLongLong>
     : public NativeValueTraitsBase<IDLUnsignedLongLong> {
-  CORE_EXPORT static inline uint64_t nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline uint64_t nativeValue(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> value,
+                                     ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, NormalConversion);
   }
 
-  CORE_EXPORT static inline uint64_t nativeValue(
+  static inline uint64_t nativeValue(
       v8::Isolate* isolate,
       v8::Local<v8::Value> value,
       ExceptionState& exceptionState,
       IntegerConversionConfiguration conversionMode) {
     return toUInt64(isolate, value, conversionMode, exceptionState);
   }
 };
 
 // Strings
 template <>
-struct NativeValueTraits<IDLByteString>
+struct CORE_EXPORT NativeValueTraits<IDLByteString>
     : public NativeValueTraitsBase<IDLByteString> {
-  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+  static inline String nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return toByteString(isolate, value, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLString> : public NativeValueTraitsBase<IDLString> {
-  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLString>
+    : public NativeValueTraitsBase<IDLString> {
+  static inline String nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return nativeValue<V8StringResourceMode::DefaultMode>(isolate, value,
                                                           exceptionState);
   }
 
   template <V8StringResourceMode Mode = DefaultMode>
-  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+  static inline String nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     V8StringResource<Mode> string(value);
     if (!string.prepare(isolate, exceptionState))
       return String();
     return string;
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUSVString>
+struct CORE_EXPORT NativeValueTraits<IDLUSVString>
     : public NativeValueTraitsBase<IDLUSVString> {
-  CORE_EXPORT static inline String nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+  static inline String nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return toUSVString(isolate, value, exceptionState);
   }
 };
 
 // Floats and doubles
 template <>
-struct NativeValueTraits<IDLDouble> : public NativeValueTraitsBase<IDLDouble> {
-  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLDouble>
+    : public NativeValueTraitsBase<IDLDouble> {
+  static inline double nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return toRestrictedDouble(isolate, value, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUnrestrictedDouble>
+struct CORE_EXPORT NativeValueTraits<IDLUnrestrictedDouble>
     : public NativeValueTraitsBase<IDLUnrestrictedDouble> {
-  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+  static inline double nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return toDouble(isolate, value, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLFloat> : public NativeValueTraitsBase<IDLFloat> {
-  CORE_EXPORT static inline float nativeValue(v8::Isolate* isolate,
-                                              v8::Local<v8::Value> value,
-                                              ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLFloat>
+    : public NativeValueTraitsBase<IDLFloat> {
+  static inline float nativeValue(v8::Isolate* isolate,
+                                  v8::Local<v8::Value> value,
+                                  ExceptionState& exceptionState) {
     return toRestrictedFloat(isolate, value, exceptionState);
   }
 };
 
 template <>
-struct NativeValueTraits<IDLUnrestrictedFloat>
+struct CORE_EXPORT NativeValueTraits<IDLUnrestrictedFloat>
     : public NativeValueTraitsBase<IDLUnrestrictedFloat> {
-  CORE_EXPORT static inline float nativeValue(v8::Isolate* isolate,
-                                              v8::Local<v8::Value> value,
-                                              ExceptionState& exceptionState) {
+  static inline float nativeValue(v8::Isolate* isolate,
+                                  v8::Local<v8::Value> value,
+                                  ExceptionState& exceptionState) {
     return toFloat(isolate, value, exceptionState);
   }
 };
 
 // Promises
 template <>
-struct NativeValueTraits<IDLPromise>
+struct CORE_EXPORT NativeValueTraits<IDLPromise>
     : public NativeValueTraitsBase<IDLPromise> {
-  CORE_EXPORT static inline ScriptPromise nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline ScriptPromise nativeValue(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> value,
+                                          ExceptionState& exceptionState) {
     return nativeValue(isolate, value);
   }
 
-  CORE_EXPORT static inline ScriptPromise nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value) {
+  static inline ScriptPromise nativeValue(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> value) {
     return ScriptPromise::cast(ScriptState::current(isolate), value);
   }
 };
 
 // Type-specific overloads
 template <>
-struct NativeValueTraits<IDLDate> : public NativeValueTraitsBase<IDLDate> {
-  CORE_EXPORT static inline double nativeValue(v8::Isolate* isolate,
-                                               v8::Local<v8::Value> value,
-                                               ExceptionState& exceptionState) {
+struct CORE_EXPORT NativeValueTraits<IDLDate>
+    : public NativeValueTraitsBase<IDLDate> {
+  static inline double nativeValue(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> value,
+                                   ExceptionState& exceptionState) {
     return toCoreDate(isolate, value, exceptionState);
   }
 };
 
 // Sequences
 template <typename T>
 struct NativeValueTraits<IDLSequence<T>>

[Yuki, 2017/03/09 07:55:29]

I think that you need CORE_TEMPLATE_CLASS_EXPORT here.

Also, IIUC, we should put CORE_TEMPLATE_CLASS_EXPORT for all the template base
classes: NativaValueTraits and NativeValueTraitsBase (including partial
specializations).

Otherwise, we'll hit a similar problem.  Please correct me if I'm wrong.

[Raphael Kubo da Costa (rakuco), 2017/03/09 08:34:49]

This was all quite confusing and I'm still not 100% sure, but what I understood
is this: CORE_TEMPLATE_CLASS_EXPORT only seems to be used together with
CORE_TEMPLATE_EXPORT, and they both follow a pattern where certain
specializations are declared either in the header or the .cpp file. For example:

  template <typename T>
  class CORE_TEMPLATE_CLASS_EXPORT C {
    ...
  };

  template class CORE_TEMPLATE_EXPORT C<int>;
  template class CORE_TEMPLATE_EXPORT C<char>;

which is not the case here. What we do here looks more similar to e.g.
//base/json/json_value_converter.h:

  template <>
  class BASE_EXPORT BasicValueConverter<bool> : public ValueConverter<bool> {

  vs.

  template <typename FieldType>
  class CustomFieldConverter : public ValueConverter<FieldType> {

additionally, I've tested this with https://codereview.chromium.org/2732093003/
on Windows and it built correctly.

[Yuki, 2017/03/09 08:41:06]

Good to know.  You should be right.

     : public NativeValueTraitsBase<IDLSequence<T>> {
   // Nondependent types need to be explicitly qualified to be accessible.
   using typename NativeValueTraitsBase<IDLSequence<T>>::ImplType;
 
-  CORE_EXPORT static inline ImplType nativeValue(
-      v8::Isolate* isolate,
-      v8::Local<v8::Value> value,
-      ExceptionState& exceptionState) {
+  static inline ImplType nativeValue(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> value,
+                                     ExceptionState& exceptionState) {
     return nativeValue(isolate, value, exceptionState, 0);
   }
 
-  CORE_EXPORT static inline ImplType nativeValue(v8::Isolate* isolate,
-                                                 v8::Local<v8::Value> value,
-                                                 ExceptionState& exceptionState,
-                                                 int index) {
+  static inline ImplType nativeValue(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> value,
+                                     ExceptionState& exceptionState,
+                                     int index) {
     return toImplArray<ImplType, T>(value, index, isolate, exceptionState);
   }
 };
 
 }  // namespace blink
 
 #endif  // NativeValueTraitsImpl_h