Rename OwnPtr::clear() to reset().

third_party/WebKit/Source/wtf/OwnPtr.h

 /*
  *  Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *  Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
@@ skipping 41 matching lines @@
     bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
 
     ~OwnPtr()
     {
         OwnedPtrDeleter<T>::deletePtr(m_ptr);
         m_ptr = nullptr;
     }
 
     PtrType get() const { return m_ptr; }
 
-    // Note: clear() will soon get renamed to reset() as a part of OwnPtr -> std::unique_ptr transition.
-    // For now, both are allowed to facilitate the rename process. See also: http://crbug.com/611661
-    void clear();
-    void reset() { clear(); }
+    void reset();
 
     PtrType leakPtr() WARN_UNUSED_RETURN;
 
     ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
     PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
 
     ValueType& operator[](std::ptrdiff_t i) const;
 
     bool operator!() const { return !m_ptr; }
     explicit operator bool() const { return m_ptr; }
 
-    OwnPtr& operator=(std::nullptr_t) { clear(); return *this; }
+    OwnPtr& operator=(std::nullptr_t) { reset(); return *this; }
 
     OwnPtr(OwnPtr&&);
     template <typename U, typename = typename std::enable_if<std::is_convertible<U*, T*>::value>::type> OwnPtr(OwnPtr<U>&&);
 
     OwnPtr& operator=(OwnPtr&&);
     template <typename U> OwnPtr& operator=(OwnPtr<U>&&);
 
     void swap(OwnPtr& o) { std::swap(m_ptr, o.m_ptr); }
 
     static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
@@ skipping 11 matching lines @@
     }
     template <typename U> bool operator!=(const OwnPtr<U>&) const
     {
         static_assert(!sizeof(U*), "OwnPtrs should never be equal");
         return false;
     }
 
     PtrType m_ptr;
 };
 
-template <typename T> inline void OwnPtr<T>::clear()
+template <typename T> inline void OwnPtr<T>::reset()
 {
     PtrType ptr = m_ptr;
     m_ptr = nullptr;
     OwnedPtrDeleter<T>::deletePtr(ptr);
 }
 
 template <typename T> inline typename OwnPtr<T>::PtrType OwnPtr<T>::leakPtr()
 {
     PtrType ptr = m_ptr;
     m_ptr = nullptr;
@@ skipping 70 matching lines @@
 template <typename T> inline typename OwnPtr<T>::PtrType getPtr(const OwnPtr<T>& p)
 {
     return p.get();
 }
 
 } // namespace WTF
 
 using WTF::OwnPtr;
 
 #endif // WTF_OwnPtr_h