Remove the TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03 macro.

skia/ext/refptr.h

 // Copyright 2012 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 SKIA_EXT_REFPTR_H_
 #define SKIA_EXT_REFPTR_H_
 
 #include <algorithm>
+#include <cstddef>
 
-#include "base/move.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace skia {
 
 // When creating/receiving a ref-counted pointer from Skia, wrap that pointer in
 // this class to avoid dealing with the ref-counting and prevent leaks/crashes
 // due to ref-counting bugs.
 //
 // Example of creating a new SkShader* and setting it on a SkPaint:
 //   skia::RefPtr<SkShader> shader = skia::AdoptRef(SkGradientShader::Create());
@@ skipping 24 matching lines @@
 //
 //   skia::RefPtr<SkShader> shader = ...;
 //   UseThisShader(shader.Pass());
 //
 // Never call ref() or unref() on the underlying ref-counted pointer. If you
 // AdoptRef() the raw pointer immediately into a skia::RefPtr and always work
 // with skia::RefPtr instances instead, the ref-counting will be taken care of
 // for you.
 template<typename T>
 class RefPtr {
-  TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(RefPtr)
  public:
   RefPtr() : ptr_(nullptr) {}
 
-  RefPtr(decltype(nullptr)) : ptr_(nullptr) {}
+  RefPtr(std::nullptr_t) : ptr_(nullptr) {}
 
+  // Copy constructor.
   RefPtr(const RefPtr& other)
       : ptr_(other.get()) {
     SkSafeRef(ptr_);
   }
 
+  // Copy conversion constructor.
   template<typename U>
   RefPtr(const RefPtr<U>& other)
       : ptr_(other.get()) {
     SkSafeRef(ptr_);
   }
 
+  // Move constructor. This is required in addition to the conversion
+  // constructor below in order for clang to warn about pessimizing moves.
+  RefPtr(RefPtr&& other) : ptr_(other.get()) { other.ptr_ = nullptr; }
+
+  // Move conversion constructor.
   template <typename U>
   RefPtr(RefPtr<U>&& other)
       : ptr_(other.get()) {
     other.ptr_ = nullptr;
   }
 
   ~RefPtr() {
     clear();
   }
 
-  RefPtr& operator=(decltype(nullptr)) {
+  RefPtr& operator=(std::nullptr_t) {
     clear();
     return *this;
   }
 
   RefPtr& operator=(const RefPtr& other) {
     SkRefCnt_SafeAssign(ptr_, other.get());
     return *this;
   }
 
   template<typename U>
   RefPtr& operator=(const RefPtr<U>& other) {
     SkRefCnt_SafeAssign(ptr_, other.get());
     return *this;
   }
 
   template <typename U>
   RefPtr& operator=(RefPtr<U>&& other) {
-    RefPtr<T> temp(other.Pass());
+    RefPtr<T> temp(std::move(other));
     std::swap(ptr_, temp.ptr_);
     return *this;
   }
 
   void clear() {
     T* to_unref = ptr_;
     ptr_ = nullptr;
     SkSafeUnref(to_unref);
   }
 
@@ skipping 31 matching lines @@
 RefPtr<T> AdoptRef(T* ptr) { return RefPtr<T>(ptr); }
 
 // For objects that are already owned. This doesn't take ownership of existing
 // references and adds a new one.
 template<typename T>
 RefPtr<T> SharePtr(T* ptr) { return RefPtr<T>(SkSafeRef(ptr)); }
 
 }  // namespace skia
 
 #endif  // SKIA_EXT_REFPTR_H_