Start removing SkNoncopyable.

Just removing these a little at a time.

Change-Id: Ieaed3dc84ca0f29f4fbda2176d92eb0df858390c
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/647038
Auto-Submit: Jim Van Verth <jvanverth@google.com>
Commit-Queue: Jim Van Verth <jvanverth@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>

fuzz/Fuzz.h

@@ -21,9 +21,14 @@
 #include <signal.h>
 #include <limits>
 
-class Fuzz : SkNoncopyable {
+class Fuzz {
 public:
     explicit Fuzz(sk_sp<SkData> bytes) : fBytes(bytes), fNextByte(0) {}
+    Fuzz() = delete;
+
+    // Make noncopyable
+    Fuzz(Fuzz&) = delete;
+    Fuzz& operator=(Fuzz&) = delete;
 
     // Returns the total number of "random" bytes available.
     size_t size() { return fBytes->size(); }

fuzz/FuzzDDLThreading.cpp

@@ -18,7 +18,6 @@
 #include "include/gpu/GrDirectContext.h"
 #include "include/private/base/SkDeque.h"
 #include "include/private/base/SkMutex.h"
-#include "include/private/base/SkNoncopyable.h"
 #include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkThreadID.h"
 #include "src/core/SkTaskGroup.h"
@@ -46,14 +45,15 @@ class DDLFuzzer;
 
 // This class stores the state of a given promise image owned by the fuzzer. It acts as the
 // context for the callback procs of the promise image.
-class PromiseImageInfo : public SkNVRefCnt<PromiseImageInfo>, SkNoncopyable {
+class PromiseImageInfo : public SkNVRefCnt<PromiseImageInfo> {
 public:
     enum class State : int {
         kInitial,
         kTriedToFulfill,
         kDone
     };
 
+    PromiseImageInfo() = default;
     ~PromiseImageInfo() {
         // If we hit this, then the image or the texture will outlive this object which is bad.
         SkASSERT_RELEASE(!fImage || fImage->unique());
@@ -64,12 +64,17 @@ class PromiseImageInfo : public SkNVRefCnt<PromiseImageInfo>, SkNoncopyable {
         SkASSERT_RELEASE(!fDrawn || s == State::kDone);
     }
 
+    // Make noncopyable
+    PromiseImageInfo(PromiseImageInfo&) = delete;
+    PromiseImageInfo& operator=(PromiseImageInfo&) = delete;
+
     DDLFuzzer* fFuzzer = nullptr;
     sk_sp<SkImage> fImage;
     // At the moment, the atomicity of this isn't used because all our promise image callbacks
     // happen on the same thread. See the TODO below about them unreffing them off the GPU thread.
     std::atomic<State> fState{State::kInitial};
     std::atomic<bool> fDrawn{false};
+
     sk_sp<SkPromiseImageTexture> fTexture;
 };
 
@@ -83,9 +88,14 @@ static constexpr int kIterationCount = 10000;
 // and concurrently records DDLs that reference them, playing each DDL back on the GPU thread.
 // The backing textures for promise images may be recycled into a pool, or not, for each case
 // as determined by the fuzzing data.
-class DDLFuzzer : SkNoncopyable {
+class DDLFuzzer {
 public:
     DDLFuzzer(Fuzz*, ContextType);
+    DDLFuzzer() = delete;
+    // Make noncopyable
+    DDLFuzzer(DDLFuzzer&) = delete;
+    DDLFuzzer& operator=(DDLFuzzer&) = delete;
+
     void run();
 
     sk_sp<SkPromiseImageTexture> fulfillPromiseImage(PromiseImageInfo&);

gm/convexpaths.cpp

@@ -17,15 +17,17 @@
 #include "include/core/SkSize.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkNoncopyable.h"
 #include "include/private/base/SkTArray.h"
 #include "src/base/SkRandom.h"
 
 namespace {
 
-class SkDoOnce : SkNoncopyable {
+class SkDoOnce {
 public:
     SkDoOnce() { fDidOnce = false; }
+    // Make noncopyable
+    SkDoOnce(SkDoOnce&) = delete;
+    SkDoOnce& operator=(SkDoOnce&) = delete;
 
     bool needToDo() const { return !fDidOnce; }
     bool alreadyDone() const { return fDidOnce; }

include/private/SkChecksum.h

@@ -11,14 +11,18 @@
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkOpts_spi.h"
-#include "include/private/base/SkNoncopyable.h"
 #include "include/private/base/SkTLogic.h"
 
 #include <string>
 #include <string_view>
 
-class SkChecksum : SkNoncopyable {
+class SkChecksum {
 public:
+    SkChecksum() = default;
+    // Make noncopyable
+    SkChecksum(const SkChecksum&) = delete;
+    SkChecksum& operator=(const SkChecksum&) = delete;
+
     /**
      * uint32_t -> uint32_t hash, useful for when you're about to trucate this hash but you
      * suspect its low bits aren't well mixed.

include/private/base/SkNoncopyable.h

@@ -10,7 +10,7 @@
 
 #include "include/private/base/SkAPI.h"
 
-/** \class SkNoncopyable
+/** \class SkNoncopyable (DEPRECATED)
 
     SkNoncopyable is the base class for objects that do not want to
     be copied. It hides its copy-constructor and its assignment-operator.

src/core/SkLRUCache.h

@@ -16,7 +16,7 @@
  * A generic LRU cache.
  */
 template <typename K, typename V, typename HashK = SkGoodHash>
-class SkLRUCache : public SkNoncopyable {
+class SkLRUCache {
 private:
     struct Entry {
         Entry(const K& key, V&& value)
@@ -31,6 +31,7 @@ class SkLRUCache : public SkNoncopyable {
 
 public:
     explicit SkLRUCache(int maxCount) : fMaxCount(maxCount) {}
+    SkLRUCache() = delete;
 
     ~SkLRUCache() {
         Entry* node = fLRU.head();
@@ -41,6 +42,10 @@ class SkLRUCache : public SkNoncopyable {
         }
     }
 
+    // Make noncopyable
+    SkLRUCache(const SkLRUCache&) = delete;
+    SkLRUCache& operator=(const SkLRUCache&) = delete;
+
     V* find(const K& key) {
         Entry** value = fMap.find(key);
         if (!value) {