Move files in wtf/ to platform/wtf/ (Part 7).

third_party/WebKit/Source/wtf/RefPtr.h

Index: third_party/WebKit/Source/wtf/RefPtr.h
diff --git a/third_party/WebKit/Source/wtf/RefPtr.h b/third_party/WebKit/Source/wtf/RefPtr.h
index 6dca0985aac0db86f39a9e777cc190ba2989d457..4fd6f103dea6f751d80e874c3491f01160c42136 100644
--- a/third_party/WebKit/Source/wtf/RefPtr.h
+++ b/third_party/WebKit/Source/wtf/RefPtr.h
@@ -1,222 +1,9 @@
-/*
- *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc.
- *  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,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- *  You should have received a copy of the GNU Library General Public License
- *  along with this library; see the file COPYING.LIB.  If not, write to
- *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
+// Copyright 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 WTF_RefPtr_h
-#define WTF_RefPtr_h
+#include "platform/wtf/RefPtr.h"
 
-#include "wtf/Allocator.h"
-#include "wtf/HashTableDeletedValueType.h"
-#include "wtf/PassRefPtr.h"
-#include "wtf/allocator/PartitionAllocator.h"
-#include <algorithm>
-#include <utility>
-
-namespace WTF {
-
-template <typename T>
-class PassRefPtr;
-template <typename T>
-class RefPtrValuePeeker;
-
-template <typename T>
-class RefPtr {
-  USING_FAST_MALLOC(RefPtr);
-
- public:
-  ALWAYS_INLINE RefPtr() : m_ptr(nullptr) {}
-  ALWAYS_INLINE RefPtr(std::nullptr_t) : m_ptr(nullptr) {}
-  ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
-  ALWAYS_INLINE explicit RefPtr(T& ref) : m_ptr(&ref) { m_ptr->ref(); }
-  ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) {
-    refIfNotNull(m_ptr);
-  }
-  template <typename U>
-  RefPtr(const RefPtr<U>& o, EnsurePtrConvertibleArgDecl(U, T))
-      : m_ptr(o.get()) {
-    refIfNotNull(m_ptr);
-  }
-  RefPtr(RefPtr&& o) : m_ptr(o.m_ptr) { o.m_ptr = nullptr; }
-
-  // See comments in PassRefPtr.h for an explanation of why this takes a const
-  // reference.
-  template <typename U>
-  RefPtr(const PassRefPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
-
-  // Hash table deleted values, which are only constructed and never copied or
-  // destroyed.
-  RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) {}
-  bool isHashTableDeletedValue() const {
-    return m_ptr == hashTableDeletedValue();
-  }
-
-  ALWAYS_INLINE ~RefPtr() { derefIfNotNull(m_ptr); }
-
-  ALWAYS_INLINE T* get() const { return m_ptr; }
-  T* leakRef() WARN_UNUSED_RESULT;
-  void clear();
-  PassRefPtr<T> release() {
-    PassRefPtr<T> tmp = adoptRef(m_ptr);
-    m_ptr = nullptr;
-    return tmp;
-  }
-
-  T& operator*() const { return *m_ptr; }
-  ALWAYS_INLINE T* operator->() const { return m_ptr; }
-
-  bool operator!() const { return !m_ptr; }
-  explicit operator bool() const { return m_ptr != nullptr; }
-
-  RefPtr& operator=(RefPtr o) {
-    swap(o);
-    return *this;
-  }
-  RefPtr& operator=(std::nullptr_t) {
-    clear();
-    return *this;
-  }
-  // This is required by HashMap<RefPtr>>.
-  template <typename U>
-  RefPtr& operator=(RefPtrValuePeeker<U>);
-
-  void swap(RefPtr&);
-
-  static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
-
- private:
-  T* m_ptr;
-};
-
-template <typename T>
-template <typename U>
-inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o,
-                         EnsurePtrConvertibleArgDefn(U, T))
-    : m_ptr(o.leakRef()) {}
-
-template <typename T>
-inline T* RefPtr<T>::leakRef() {
-  T* ptr = m_ptr;
-  m_ptr = nullptr;
-  return ptr;
-}
-
-template <typename T>
-inline void RefPtr<T>::clear() {
-  T* ptr = m_ptr;
-  m_ptr = nullptr;
-  derefIfNotNull(ptr);
-}
-
-template <typename T>
-template <typename U>
-inline RefPtr<T>& RefPtr<T>::operator=(RefPtrValuePeeker<U> optr) {
-  RefPtr ptr = static_cast<U*>(optr);
-  swap(ptr);
-  return *this;
-}
-
-template <class T>
-inline void RefPtr<T>::swap(RefPtr& o) {
-  std::swap(m_ptr, o.m_ptr);
-}
-
-template <class T>
-inline void swap(RefPtr<T>& a, RefPtr<T>& b) {
-  a.swap(b);
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() == b.get();
-}
-
-template <typename T, typename U>
-inline bool operator==(const RefPtr<T>& a, U* b) {
-  return a.get() == b;
-}
-
-template <typename T, typename U>
-inline bool operator==(T* a, const RefPtr<U>& b) {
-  return a == b.get();
-}
-
-template <typename T>
-inline bool operator==(const RefPtr<T>& a, std::nullptr_t) {
-  return !a.get();
-}
-
-template <typename T>
-inline bool operator==(std::nullptr_t, const RefPtr<T>& b) {
-  return !b.get();
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.get() != b.get();
-}
-
-template <typename T, typename U>
-inline bool operator!=(const RefPtr<T>& a, U* b) {
-  return a.get() != b;
-}
-
-template <typename T, typename U>
-inline bool operator!=(T* a, const RefPtr<U>& b) {
-  return a != b.get();
-}
-
-template <typename T>
-inline bool operator!=(const RefPtr<T>& a, std::nullptr_t) {
-  return a.get();
-}
-
-template <typename T>
-inline bool operator!=(std::nullptr_t, const RefPtr<T>& b) {
-  return b.get();
-}
-
-template <typename T>
-inline T* getPtr(const RefPtr<T>& p) {
-  return p.get();
-}
-
-template <typename T>
-class RefPtrValuePeeker {
-  DISALLOW_NEW();
-
- public:
-  ALWAYS_INLINE RefPtrValuePeeker(T* p) : m_ptr(p) {}
-  ALWAYS_INLINE RefPtrValuePeeker(std::nullptr_t) : m_ptr(nullptr) {}
-  template <typename U>
-  RefPtrValuePeeker(const RefPtr<U>& p) : m_ptr(p.get()) {}
-  template <typename U>
-  RefPtrValuePeeker(const PassRefPtr<U>& p) : m_ptr(p.get()) {}
-
-  ALWAYS_INLINE operator T*() const { return m_ptr; }
-
- private:
-  T* m_ptr;
-};
-
-}  // namespace WTF
-
-using WTF::RefPtr;
-
-#endif  // WTF_RefPtr_h
+// The contents of this header was moved to platform/wtf as part of
+// WTF migration project. See the following post for details:
+// https://groups.google.com/a/chromium.org/d/msg/blink-dev/tLdAZCTlcAA/bYXVT8gYCAAJ