[oilpan] Make the oilpan branch build on Mac.

Source/heap/Handle.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 1332 matching lines @@
 
     template<typename T, typename U>
     static void visitWith(Visitor* visitor, const WTF::KeyValuePair<T, Member<U> >& t, bool needsVisiting)
     {
         visitor->visit(t.value);
     }
 
     template<typename T>
     struct IteratorWitness {
         typedef HandleWitness<T> Type;
-        static void verify(Type witness, const T* collection) { witness.verify(collection); }
+        static void verifyWitness(Type witness, const T* collection) { witness.verifyWitness(collection); }
     };
     // This class is intentionally left undefined. The name is intended to
     // be the error message you get when calling a method that needs to
     // create iterators, if you forget to give it the address of a handle
     // that ensures the collection is kept alive while you iterate over it.
     class YouMustProvideAHandleToThatMethod;
     typedef YouMustProvideAHandleToThatMethod DefaultArgument;
 
     template<typename T> friend class Handle;
     template<typename T> friend class Persistent;
 };
 
 // An instance of this class is used when creating iterators to prove that you
 // have a handle for the collection, so that it cannot be garbage collected
 // while the iterator is live. We need this indirection, rather than just using
 // the handle pointer directly, because the Handle<T> and Handle<const T>
 // pointers are not related, and we want to be able to pass either.
 template<typename T>
 class HandleWitness {
 public:
     HandleWitness(const Handle<const T>* handle) : m_handle(handle) { }
     HandleWitness(const Handle<T>* handle) : m_handle(reinterpret_cast<const Handle<const T>*>(handle)) { }
-    void verify(const T* pointer) { ASSERT((!pointer && !m_handle) || pointer == m_handle->raw()); }
+    void verifyWitness(const T* pointer) { ASSERT((!pointer && !m_handle) || pointer == m_handle->raw()); }
     template<typename U>
     explicit HandleWitness(const HandleWitness<U>& other) : m_handle(reinterpret_cast<const Handle<const T>*>(other.m_handle)) { }
 private:
     const Handle<const T>* m_handle;
     template<typename U>
     friend class HandleWitness;
 };
 
 }
 
@@ skipping 49 matching lines @@
     typedef PtrHash<WebCore::Member<T> > Hash;
 };
 
 #define DEFINE_SELF_HANDLE(Type)                                   \
     Result<Type> selfHandle() { return adoptRawResult(this); }             \
     Result<const Type> selfHandle() const { return adoptRawResult(this); }
 
 }
 
 #endif