[oilpan] Make the oilpan branch build on Mac.

Source/heap/Visitor.h

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 66 matching lines @@
     static intptr_t getTypeMarker()
     {
 #ifndef NDEBUG
         return reinterpret_cast<intptr_t>(&T::s_gcTypeMarker);
 #else
         return 0;
 #endif
     }
 
 #ifndef NDEBUG
-    static void check(Visitor*, const T*);
+    static void checkTypeMarker(Visitor*, const T*);
 #endif
 };
 
 template<typename U> class AcceptTrait<const U> : public AcceptTrait<U> { };
 
 class Visitor {
 public:
     // One-argument templated visit method. This uses the static type of
     // the argument to get the AcceptTrait. By default, the visit method
     // of the AcceptTrait just calls the virtual two-argument visit method on this
     // visitor, where the second argument is the static accept method.
     template<typename T>
     void visit(T* t)
     {
         if (!t)
             return;
 #ifndef NDEBUG
-        AcceptTrait<T>::check(this, t);
+        AcceptTrait<T>::checkTypeMarker(this, t);
 #endif
         AcceptTrait<T>::visit(this, t);
     }
 
     // Member version of the one-argument templated visit method.
     template<typename T>
     void visit(const Member<T>& t)
     {
         if (!t)
             return;
 #ifndef NDEBUG
-        AcceptTrait<T>::check(this, t.raw());
+        AcceptTrait<T>::checkTypeMarker(this, t.raw());
 #endif
         AcceptTrait<T>::visit(this, t.raw());
     }
 
     // Result version of the one-argument templated visit method. This is used
     // for visiting collections: The iterator returns Result<T> and we visit
     // them. This visitor method is befriended by Result<T> which allows it to
     // use releaseRaw.
     template<typename T>
     void visit(const Result<T>& t) { visit(t.releaseRaw()); }
@@ skipping 34 matching lines @@
     // to objects where isAlive returned false.
     virtual void registerWeakPointers(const void*, WeakPointerCallback) { }
     virtual bool isAlive(const void*) { return false; }
 
 #ifndef NDEBUG
     void checkTypeMarker(const void*, intptr_t marker);
 #endif
 };
 
 #ifndef NDEBUG
-template<typename T> void AcceptTrait<T>::check(Visitor* visitor, const T* t)
+template<typename T> void AcceptTrait<T>::checkTypeMarker(Visitor* visitor, const T* t)
 {
     visitor->checkTypeMarker(const_cast<T*>(t), getTypeMarker());
 }
 #endif
 
 template<typename T> void AcceptTrait<T>::visit(Visitor* visitor, const T* t)
 {
     // Default visit method of the trait just calls the two-argument visit
     // method on the visitor. The second argument is the static accept method
     // of the trait, which by default calls the instance method
     // accept(Visitor*) on the object.
     visitor->visit(const_cast<T*>(t), &accept);
 }
 
 inline void doNothingAccept(Visitor*, void*)
 {
 }
 
 // Non-class types like float don't have an accept method, so we provide a more
 // specialized template instantiation here that will be selected in preference
 // to the default. Most of them do nothing, since the type in question cannot
 // point to other heap allocated objects.
 #define DO_NOTHING_TRAIT(type)                       \
     template<>                                       \
     class AcceptTrait<type> {                        \
     public:                                          \
         static void accept(Visitor*, void*) { }      \
-        static void check(Visitor*, const void*) { } \
+        static void checkTypeMarker(Visitor*, const void*) { } \

[Erik Corry, 2013/08/23 11:20:19]

These backslashes are kinda messy.

         static void visit(Visitor* v, type* p) {     \
             v->visit(p, &accept);                    \
         }                                            \
         static intptr_t getTypeMarker()              \
         {                                            \
             return 0;                                \
         }                                            \
     }
 DO_NOTHING_TRAIT(const float);
 DO_NOTHING_TRAIT(uint8_t);
@@ skipping 79 matching lines @@
 public:
     virtual void accept(Visitor*) = 0;
     virtual ~HeapVisitable()
     {
     }
 };
 
 }
 
 #endif