Remove V8_INLINE from v8-util.h.

include/v8-util.h

 // Copyright 2014 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
@@ skipping 123 matching lines @@
  * directly in std containers.
  *
  * The map relies on a backing map, whose type and accessors are described
  * by the Traits class. The backing map will handle values of type
  * PersistentContainerValue, with all conversion into and out of V8
  * handles being transparently handled by this class.
  */
 template<typename K, typename V, typename Traits>
 class PersistentValueMap {
  public:
-  V8_INLINE explicit PersistentValueMap(Isolate* isolate) : isolate_(isolate) {}
+  explicit PersistentValueMap(Isolate* isolate) : isolate_(isolate) {}
 
-  V8_INLINE ~PersistentValueMap() { Clear(); }
+  ~PersistentValueMap() { Clear(); }
 
-  V8_INLINE Isolate* GetIsolate() { return isolate_; }
+  Isolate* GetIsolate() { return isolate_; }
 
   /**
    * Return size of the map.
    */
-  V8_INLINE size_t Size() { return Traits::Size(&impl_); }
+  size_t Size() { return Traits::Size(&impl_); }
 
   /**
    * Return whether the map holds weak persistents.
    */
-  V8_INLINE bool IsWeak() { return Traits::kCallbackType != kNotWeak; }
+  bool IsWeak() { return Traits::kCallbackType != kNotWeak; }
 
   /**
    * Get value stored in map.
    */
-  V8_INLINE Local<V> Get(const K& key) {
+  Local<V> Get(const K& key) {
     return Local<V>::New(isolate_, FromVal(Traits::Get(&impl_, key)));
   }
 
   /**
    * Check whether a value is contained in the map.
    */
-  V8_INLINE bool Contains(const K& key) {
+  bool Contains(const K& key) {
     return Traits::Get(&impl_, key) != kPersistentContainerNotFound;
   }
 
   /**
    * Get value stored in map and set it in returnValue.
    * Return true if a value was found.
    */
-  V8_INLINE bool SetReturnValue(const K& key,
+  bool SetReturnValue(const K& key,
       ReturnValue<Value> returnValue) {
     return SetReturnValueFromVal(returnValue, Traits::Get(&impl_, key));
   }
 
   /**
    * Call Isolate::SetReference with the given parent and the map value.
    */
-  V8_INLINE void SetReference(const K& key,
+  void SetReference(const K& key,
       const Persistent<Object>& parent) {
     GetIsolate()->SetReference(
       reinterpret_cast<internal::Object**>(parent.val_),
       reinterpret_cast<internal::Object**>(FromVal(Traits::Get(&impl_, key))));
   }
 
   /**
    * Put value into map. Depending on Traits::kIsWeak, the value will be held
    * by the map strongly or weakly.
    * Returns old value as UniquePersistent.
@@ skipping 78 matching lines @@
   /**
    * Get a reference to a map value. This enables fast, repeated access
    * to a value stored in the map while the map remains unchanged.
    *
    * Careful: This is potentially unsafe, so please use with care.
    * The value will become invalid if the value for this key changes
    * in the underlying map, as a result of Set or Remove for the same
    * key; as a result of the weak callback for the same key; or as a
    * result of calling Clear() or destruction of the map.
    */
-  V8_INLINE PersistentValueReference GetReference(const K& key) {
+  PersistentValueReference GetReference(const K& key) {
     return PersistentValueReference(Traits::Get(&impl_, key));
   }
 
   /**
    * Put a value into the map and update the reference.
    * Restrictions of GetReference apply here as well.
    */
   UniquePersistent<V> Set(const K& key, UniquePersistent<V> value,
                           PersistentValueReference* reference) {
     *reference = Leak(&value);
@@ skipping 23 matching lines @@
       const WeakCallbackData<V, typename Traits::WeakCallbackDataType>& data) {
     if (Traits::kCallbackType != kNotWeak) {
       PersistentValueMap<K, V, Traits>* persistentValueMap =
           Traits::MapFromWeakCallbackData(data);
       K key = Traits::KeyFromWeakCallbackData(data);
       Traits::Dispose(data.GetIsolate(),
                       persistentValueMap->Remove(key).Pass(), key);
     }
   }
 
-  V8_INLINE static V* FromVal(PersistentContainerValue v) {
+  static V* FromVal(PersistentContainerValue v) {
     return reinterpret_cast<V*>(v);
   }
 
-  V8_INLINE static bool SetReturnValueFromVal(
+  static bool SetReturnValueFromVal(
       ReturnValue<Value>& returnValue, PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
     if (hasValue) {
       returnValue.SetInternal(
           *reinterpret_cast<internal::Object**>(FromVal(value)));
     }
     return hasValue;
   }
 
-  V8_INLINE static PersistentContainerValue ClearAndLeak(
+  static PersistentContainerValue ClearAndLeak(
       UniquePersistent<V>* persistent) {
     V* v = persistent->val_;
     persistent->val_ = 0;
     return reinterpret_cast<PersistentContainerValue>(v);
   }
 
-  V8_INLINE static PersistentContainerValue Leak(
+  static PersistentContainerValue Leak(
       UniquePersistent<V>* persistent) {
     return reinterpret_cast<PersistentContainerValue>(persistent->val_);
   }
 
   /**
    * Return a container value as UniquePersistent and make sure the weak
    * callback is properly disposed of. All remove functionality should go
    * through this.
    */
   static UniquePersistent<V> Release(PersistentContainerValue v) {
@@ skipping 139 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H_