Add a SkTLazy copy assignment operator

include/core/SkTLazy.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTLazy_DEFINED
 #define SkTLazy_DEFINED
 
 #include "../private/SkTemplates.h"
 #include "SkTypes.h"
 #include <new>
 #include <utility>
 
 /**
  *  Efficient way to defer allocating/initializing a class until it is needed
  *  (if ever).
  */
 template <typename T> class SkTLazy {
 public:
-    SkTLazy() : fPtr(NULL) {}
+    SkTLazy() : fPtr(nullptr) {}
 
-    explicit SkTLazy(const T* src) : fPtr(NULL) {
-        if (src) {
-            fPtr = new (fStorage.get()) T(*src);
-        }
-    }
+    explicit SkTLazy(const T* src)
+        : fPtr(src ? new (fStorage.get()) T(*src) : nullptr) {}
 
-    SkTLazy(const SkTLazy<T>& src) : fPtr(NULL) {
-        if (src.isValid()) {
-            fPtr = new (fStorage.get()) T(*src.get());
-        } else {
-            fPtr = NULL;
-        }
-    }
+    SkTLazy(const SkTLazy& src) : fPtr(nullptr) { *this = src; }
 
     ~SkTLazy() {
         if (this->isValid()) {
             fPtr->~T();
         }
     }
 
+    SkTLazy& operator=(const SkTLazy& src) {
+        if (src.isValid()) {
+            this->set(*src.get());
+        } else {
+            this->reset();
+        }
+        return *this;
+    }
+
     /**
      *  Return a pointer to an instance of the class initialized with 'args'.
      *  If a previous instance had been initialized (either from init() or
      *  set()) it will first be destroyed, so that a freshly initialized
      *  instance is always returned.
      */
     template <typename... Args> T* init(Args&&... args) {
         if (this->isValid()) {
             fPtr->~T();
         }
@@ skipping 15 matching lines @@
         }
         return fPtr;
     }
 
     /**
      * Destroy the lazy object (if it was created via init() or set())
      */
     void reset() {
         if (this->isValid()) {
             fPtr->~T();
-            fPtr = NULL;
+            fPtr = nullptr;
         }
     }
 
     /**
      *  Returns true if a valid object has been initialized in the SkTLazy,
      *  false otherwise.
      */
     bool isValid() const { return SkToBool(fPtr); }
 
     /**
      * Returns the object. This version should only be called when the caller
      * knows that the object has been initialized.
      */
     T* get() const { SkASSERT(this->isValid()); return fPtr; }
 
     /**
      * Like above but doesn't assert if object isn't initialized (in which case
-     * NULL is returned).
+     * nullptr is returned).
      */
     T* getMaybeNull() const { return fPtr; }
 
 private:
-    T* fPtr; // NULL or fStorage
+    T* fPtr; // nullptr or fStorage
     SkAlignedSTStorage<1, T> fStorage;
 };
 
 /**
  * A helper built on top of SkTLazy to do copy-on-first-write. The object is initialized
  * with a const pointer but provides a non-const pointer accessor. The first time the
  * accessor is called (if ever) the object is cloned.
  *
  * In the following example at most one copy of constThing is made:
  *
@@ skipping 14 matching lines @@
  * consume_a_thing(thing); // could be constThing or a modified copy.
  */
 template <typename T>
 class SkTCopyOnFirstWrite {
 public:
     SkTCopyOnFirstWrite(const T& initial) : fObj(&initial) {}
 
     SkTCopyOnFirstWrite(const T* initial) : fObj(initial) {}
 
     // Constructor for delayed initialization.
-    SkTCopyOnFirstWrite() : fObj(NULL) {}
+    SkTCopyOnFirstWrite() : fObj(nullptr) {}
 
     // Should only be called once, and only if the default constructor was used.
     void init(const T& initial) {
-        SkASSERT(NULL == fObj);
+        SkASSERT(nullptr == fObj);
         SkASSERT(!fLazy.isValid());
         fObj = &initial;
     }
 
     /**
      * Returns a writable T*. The first time this is called the initial object is cloned.
      */
     T* writable() {
         SkASSERT(fObj);
         if (!fLazy.isValid()) {
@@ skipping 12 matching lines @@
     operator const T*() const { return fObj; }
 
     const T& operator *() const { return *fObj; }
 
 private:
     const T*    fObj;
     SkTLazy<T>  fLazy;
 };
 
 #endif