Adds local coords to GrEffect system.

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 "SkTypes.h"
 #include <new>
 
+template <typename T> class SkTLazy;
+template <typename T> void* operator new(size_t, SkTLazy<T>* lazy);
+
 /**
  *  Efficient way to defer allocating/initializing a class until it is needed
  *  (if ever).
  */
 template <typename T> class SkTLazy {
 public:
     SkTLazy() : fPtr(NULL) {}
 
     explicit SkTLazy(const T* src) : fPtr(NULL) {
         if (src) {
@@ skipping 10 matching lines @@
     }
 
     ~SkTLazy() {
         if (this->isValid()) {
             fPtr->~T();
         }
     }
 
     /**
      *  Return a pointer to a default-initialized instance of the class. If a
-     *  previous instance had been initialzied (either from init() or set()) it
+     *  previous instance had been initialized (either from init() or set()) it
      *  will first be destroyed, so that a freshly initialized instance is
      *  always returned.
      */
     T* init() {
         if (this->isValid()) {
             fPtr->~T();
         }
         fPtr = new (SkTCast<T*>(fStorage)) T;
         return fPtr;
     }
@@ skipping 19 matching lines @@
      */
     bool isValid() const { return NULL != fPtr; }
 
     /**
      *  Returns either NULL, or a copy of the object that was passed to
      *  set() or the constructor.
      */
     T* get() const { SkASSERT(this->isValid()); return fPtr; }
 
 private:
+    friend void* operator new<T>(size_t, SkTLazy* lazy);
+
     T*   fPtr; // NULL or fStorage
     char fStorage[sizeof(T)];
 };
 
+// Use the below macro (SkNEW_IN_TLAZY) rather than calling this directly
+template <typename T> void* operator new(size_t, SkTLazy<T>* lazy) {
+    SkASSERT(!lazy->isValid());
+    lazy->fPtr = reinterpret_cast<T*>(lazy->fStorage);
+    return lazy->fPtr;
+}
+
+// Skia doesn't use C++ exceptions but it may be compiled with them enabled. Having an op delete
+// to match the op new silences warnings about missing op delete when a constructor throws an
+// exception.
+template <typename T> void operator delete(void*, SkTLazy<T>) { SK_CRASH(); }
+
+// Use this to construct a T inside an SkTLazy using a non-default constructor.
+#define SkNEW_IN_TLAZY(tlazy_ptr, type_name, args) (new (tlazy_ptr) type_name args)
+
 /**
  * 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:
  *
  * SkTCopyOnFirstWrite<Thing> thing(&constThing);
  * ...
  * function_that_takes_a_const_thing_ptr(thing); // constThing is passed
@@ skipping 46 matching lines @@
     operator const T*() const { return fObj; }
 
     const T& operator *() const { return *fObj; }
 
 private:
     const T*    fObj;
     SkTLazy<T>  fLazy;
 };
 
 #endif