From 9b62e5f64ecb53586611725c58977f53779e805c Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Mon, 5 May 2014 14:40:11 +1000
Subject: [PATCH] beginning nan@1.0.0 conversion

---
 package.json                    |  2 +-
 src/Canvas.cc                   | 68 ++++++++++++++--------------
 src/CanvasGradient.cc           |  4 +-
 src/CanvasPattern.cc            |  4 +-
 src/CanvasRenderingContext2d.cc | 80 ++++++++++++++++-----------------
 src/FontFace.cc                 |  4 +-
 src/Image.cc                    | 26 +++++------
 src/ImageData.cc                |  8 ++--
 src/JPEGStream.h                | 24 +++++-----
 src/PixelArray.cc               | 10 ++---
 src/closure.h                   |  2 +-
 src/init.cc                     |  8 ++--
 12 files changed, 120 insertions(+), 120 deletions(-)

diff --git a/package.json b/package.json
index a940eed..c131103 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,7 @@
      "test": "make test"
  }
  , "dependencies": {
-     "nan": "~0.7.0"
+     "nan": "~1.0.0"
  }
  , "devDependencies": {
      "express": "3.0"
diff --git a/src/Canvas.cc b/src/Canvas.cc
index 306904f..6f12ba6 100644
--- a/src/Canvas.cc
+++ b/src/Canvas.cc
@@ -30,8 +30,8 @@ Canvas::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(Canvas::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Canvas::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("Canvas"));
 
@@ -46,13 +46,13 @@ Canvas::Initialize(Handle<Object> target) {
   proto->SetAccessor(NanSymbol("width"), GetWidth, SetWidth);
   proto->SetAccessor(NanSymbol("height"), GetHeight, SetHeight);
 
-  proto->Set("PNG_NO_FILTERS", Uint32::New(PNG_NO_FILTERS));
-  proto->Set("PNG_FILTER_NONE", Uint32::New(PNG_FILTER_NONE));
-  proto->Set("PNG_FILTER_SUB", Uint32::New(PNG_FILTER_SUB));
-  proto->Set("PNG_FILTER_UP", Uint32::New(PNG_FILTER_UP));
-  proto->Set("PNG_FILTER_AVG", Uint32::New(PNG_FILTER_AVG));
-  proto->Set("PNG_FILTER_PAETH", Uint32::New(PNG_FILTER_PAETH));
-  proto->Set("PNG_ALL_FILTERS", Uint32::New(PNG_ALL_FILTERS));
+  NanSetTemplate(proto, "PNG_NO_FILTERS", NanNew<Uint32>(PNG_NO_FILTERS));
+  NanSetTemplate(proto, "PNG_FILTER_NONE", NanNew<Uint32>(PNG_FILTER_NONE));
+  NanSetTemplate(proto, "PNG_FILTER_SUB", NanNew<Uint32>(PNG_FILTER_SUB));
+  NanSetTemplate(proto, "PNG_FILTER_UP", NanNew<Uint32>(PNG_FILTER_UP));
+  NanSetTemplate(proto, "PNG_FILTER_AVG", NanNew<Uint32>(PNG_FILTER_AVG));
+  NanSetTemplate(proto, "PNG_FILTER_PAETH", NanNew<Uint32>(PNG_FILTER_PAETH));
+  NanSetTemplate(proto, "PNG_ALL_FILTERS", NanNew<Uint32>(PNG_ALL_FILTERS));
 
   target->Set(NanSymbol("Canvas"), ctor->GetFunction());
 }
@@ -82,7 +82,7 @@ NAN_METHOD(Canvas::New) {
 NAN_GETTER(Canvas::GetType) {
   NanScope();
   Canvas *canvas = ObjectWrap::Unwrap<Canvas>(args.This());
-  NanReturnValue(String::New(canvas->isPDF() ? "pdf" : "image"));
+  NanReturnValue(NanNew<String>(canvas->isPDF() ? "pdf" : "image"));
 }
 
 /*
@@ -92,7 +92,7 @@ NAN_GETTER(Canvas::GetType) {
 NAN_GETTER(Canvas::GetWidth) {
   NanScope();
   Canvas *canvas = ObjectWrap::Unwrap<Canvas>(args.This());
-  NanReturnValue(Number::New(canvas->width));
+  NanReturnValue(NanNew<Number>(canvas->width));
 }
 
 /*
@@ -115,7 +115,7 @@ NAN_SETTER(Canvas::SetWidth) {
 NAN_GETTER(Canvas::GetHeight) {
   NanScope();
   Canvas *canvas = ObjectWrap::Unwrap<Canvas>(args.This());
-  NanReturnValue(Number::New(canvas->height));
+  NanReturnValue(NanNew<Number>(canvas->height));
 }
 
 /*
@@ -211,7 +211,7 @@ Canvas::EIO_AfterToBuffer(eio_req *req) {
   } else {
     Local<Object> buf = NanNewBufferHandle((char*)closure->data, closure->len);
     memcpy(Buffer::Data(buf), closure->data, closure->len);
-    Local<Value> argv[2] = { NanNewLocal<Value>(Null()), buf };
+    Local<Value> argv[2] = { NanNull(), buf };
     closure->pfn->Call(2, argv);
   }
 
@@ -246,13 +246,13 @@ NAN_METHOD(Canvas::ToBuffer) {
     NanReturnValue(buf);
   }
 
-  if (args.Length() > 1 && !(args[1]->StrictEquals(Undefined()) && args[2]->StrictEquals(Undefined()))) {
-    if (!args[1]->StrictEquals(Undefined())) {
+  if (args.Length() > 1 && !(args[1]->StrictEquals(NanUndefined()) && args[2]->StrictEquals(NanUndefined()))) {
+    if (!args[1]->StrictEquals(NanUndefined())) {
         bool good = true;
         if (args[1]->IsNumber()) {
           compression_level = args[1]->Uint32Value();
         } else if (args[1]->IsString()) {
-          if (args[1]->StrictEquals(String::New("0"))) {
+          if (args[1]->StrictEquals(NanNew<String>("0"))) {
             compression_level = 0;
           } else {
             uint32_t tmp = args[1]->Uint32Value();
@@ -275,7 +275,7 @@ NAN_METHOD(Canvas::ToBuffer) {
        }
     }
 
-    if (!args[2]->StrictEquals(Undefined())) {
+    if (!args[2]->StrictEquals(NanUndefined())) {
       if (args[2]->IsUint32()) {
         filter = args[2]->Uint32Value();
       } else {
@@ -348,10 +348,10 @@ streamPNG(void *c, const uint8_t *data, unsigned len) {
   closure_t *closure = (closure_t *) c;
   Local<Object> buf = NanNewBufferHandle((char *)data, len);
   Local<Value> argv[3] = {
-      NanNewLocal<Value>(Null())
+      NanNull()
     , buf
-    , Integer::New(len) };
-  MakeCallback(Context::GetCurrent()->Global(), closure->fn, 3, argv);
+    , NanNew<Integer>(len) };
+  NanMakeCallback(NanGetCurrentContext(), closure->fn, 3, argv);
   return CAIRO_STATUS_SUCCESS;
 }
 
@@ -367,13 +367,13 @@ NAN_METHOD(Canvas::StreamPNGSync) {
   if (!args[0]->IsFunction())
     return NanThrowTypeError("callback function required");
 
-  if (args.Length() > 1 && !(args[1]->StrictEquals(Undefined()) && args[2]->StrictEquals(Undefined()))) {
-    if (!args[1]->StrictEquals(Undefined())) {
+  if (args.Length() > 1 && !(args[1]->StrictEquals(NanUndefined()) && args[2]->StrictEquals(NanUndefined()))) {
+    if (!args[1]->StrictEquals(NanUndefined())) {
         bool good = true;
         if (args[1]->IsNumber()) {
           compression_level = args[1]->Uint32Value();
         } else if (args[1]->IsString()) {
-          if (args[1]->StrictEquals(String::New("0"))) {
+          if (args[1]->StrictEquals(NanNew<String>("0"))) {
             compression_level = 0;
           } else {
             uint32_t tmp = args[1]->Uint32Value();
@@ -396,7 +396,7 @@ NAN_METHOD(Canvas::StreamPNGSync) {
        }
     }
 
-    if (!args[2]->StrictEquals(Undefined())) {
+    if (!args[2]->StrictEquals(NanUndefined())) {
       if (args[2]->IsUint32()) {
         filter = args[1]->Uint32Value();
       } else {
@@ -420,13 +420,13 @@ NAN_METHOD(Canvas::StreamPNGSync) {
     NanReturnValue(try_catch.ReThrow());
   } else if (status) {
     Local<Value> argv[1] = { Canvas::Error(status) };
-    MakeCallback(Context::GetCurrent()->Global(), closure.fn, 1, argv);
+    NanMakeCallback(NanGetCurrentContext(), closure.fn, 1, argv);
   } else {
     Local<Value> argv[3] = {
-        NanNewLocal<Value>(Null())
-      , NanNewLocal<Value>(Null())
-      , Integer::New(0) };
-    MakeCallback(Context::GetCurrent()->Global(), closure.fn, 3, argv);
+        NanNull()
+      , NanNull()
+      , NanNew<Integer>(0) };
+    NanMakeCallback(NanGetCurrentContext(), closure.fn, 3, argv);
   }
   NanReturnUndefined();
 }
@@ -483,7 +483,7 @@ Canvas::Canvas(int w, int h, canvas_type_t t): ObjectWrap() {
   } else {
     _surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h);
     assert(_surface);
-    V8::AdjustAmountOfExternalAllocatedMemory(4 * w * h);
+    NanAdjustExternalMemory(4 * w * h);
   }
 }
 
@@ -501,7 +501,7 @@ Canvas::~Canvas() {
       break;
     case CANVAS_TYPE_IMAGE:
       cairo_surface_destroy(_surface);
-      V8::AdjustAmountOfExternalAllocatedMemory(-4 * width * height);
+      NanAdjustExternalMemory(-4 * width * height);
       break;
   }
 }
@@ -522,10 +522,10 @@ Canvas::resurface(Handle<Object> canvas) {
       int old_height = cairo_image_surface_get_height(_surface);
       cairo_surface_destroy(_surface);
       _surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
-      V8::AdjustAmountOfExternalAllocatedMemory(4 * (width * height - old_width * old_height));
+      NanAdjustExternalMemory(4 * (width * height - old_width * old_height));
 
       // Reset context
-      Handle<Value> context = canvas->Get(String::New("context"));
+      Handle<Value> context = canvas->Get(NanNew<String>("context"));
       if (!context->IsUndefined()) {
         Context2d *context2d = ObjectWrap::Unwrap<Context2d>(context->ToObject());
         cairo_t *prev = context2d->context();
@@ -542,5 +542,5 @@ Canvas::resurface(Handle<Object> canvas) {
 
 Local<Value>
 Canvas::Error(cairo_status_t status) {
-  return Exception::Error(String::New(cairo_status_to_string(status)));
+  return Exception::Error(NanNew<String>(cairo_status_to_string(status)));
 }
diff --git a/src/CanvasGradient.cc b/src/CanvasGradient.cc
index 802224e..2bf7f61 100644
--- a/src/CanvasGradient.cc
+++ b/src/CanvasGradient.cc
@@ -20,8 +20,8 @@ Gradient::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(Gradient::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Gradient::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("CanvasGradient"));
 
diff --git a/src/CanvasPattern.cc b/src/CanvasPattern.cc
index 16bb99f..d874bf4 100644
--- a/src/CanvasPattern.cc
+++ b/src/CanvasPattern.cc
@@ -20,8 +20,8 @@ Pattern::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(Pattern::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Pattern::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("CanvasPattern"));
 
diff --git a/src/CanvasRenderingContext2d.cc b/src/CanvasRenderingContext2d.cc
index a6c1621..19902c2 100644
--- a/src/CanvasRenderingContext2d.cc
+++ b/src/CanvasRenderingContext2d.cc
@@ -81,8 +81,8 @@ Context2d::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(Context2d::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Context2d::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("CanvasRenderingContext2d"));
 
@@ -694,7 +694,7 @@ NAN_METHOD(Context2d::DrawImage) {
 NAN_GETTER(Context2d::GetGlobalAlpha) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(context->state->globalAlpha));
+  NanReturnValue(NanNew<Number>(context->state->globalAlpha));
 }
 
 /*
@@ -878,7 +878,7 @@ NAN_SETTER(Context2d::SetGlobalCompositeOperation) {
 NAN_GETTER(Context2d::GetShadowOffsetX) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(context->state->shadowOffsetX));
+  NanReturnValue(NanNew<Number>(context->state->shadowOffsetX));
 }
 
 /*
@@ -897,7 +897,7 @@ NAN_SETTER(Context2d::SetShadowOffsetX) {
 NAN_GETTER(Context2d::GetShadowOffsetY) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(context->state->shadowOffsetY));
+  NanReturnValue(NanNew<Number>(context->state->shadowOffsetY));
 }
 
 /*
@@ -916,7 +916,7 @@ NAN_SETTER(Context2d::SetShadowOffsetY) {
 NAN_GETTER(Context2d::GetShadowBlur) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(context->state->shadowBlur));
+  NanReturnValue(NanNew<Number>(context->state->shadowBlur));
 }
 
 /*
@@ -1050,7 +1050,7 @@ NAN_SETTER(Context2d::SetFilter) {
 NAN_GETTER(Context2d::GetMiterLimit) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(cairo_get_miter_limit(context->context())));
+  NanReturnValue(NanNew<Number>(cairo_get_miter_limit(context->context())));
 }
 
 /*
@@ -1072,7 +1072,7 @@ NAN_SETTER(Context2d::SetMiterLimit) {
 NAN_GETTER(Context2d::GetLineWidth) {
   NanScope();
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
-  NanReturnValue(Number::New(cairo_get_line_width(context->context())));
+  NanReturnValue(NanNew<Number>(cairo_get_line_width(context->context())));
 }
 
 /*
@@ -1164,7 +1164,7 @@ NAN_METHOD(Context2d::IsPointInPath) {
     cairo_t *ctx = context->context();
     double x = args[0]->NumberValue()
          , y = args[1]->NumberValue();
-    NanReturnValue(Boolean::New(cairo_in_fill(ctx, x, y) || cairo_in_stroke(ctx, x, y)));
+    NanReturnValue(NanNew<Boolean>(cairo_in_fill(ctx, x, y) || cairo_in_stroke(ctx, x, y)));
   }
   NanReturnValue(False());
 }
@@ -1237,7 +1237,7 @@ NAN_GETTER(Context2d::GetShadowColor) {
   char buf[64];
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
   rgba_to_string(context->state->shadow, buf, sizeof(buf));
-  NanReturnValue(String::New(buf));
+  NanReturnValue(NanNew<String>(buf));
 }
 
 /*
@@ -1266,7 +1266,7 @@ NAN_GETTER(Context2d::GetFillColor) {
   char buf[64];
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
   rgba_to_string(context->state->fill, buf, sizeof(buf));
-  NanReturnValue(String::New(buf));
+  NanReturnValue(NanNew<String>(buf));
 }
 
 /*
@@ -1295,7 +1295,7 @@ NAN_GETTER(Context2d::GetStrokeColor) {
   char buf[64];
   Context2d *context = ObjectWrap::Unwrap<Context2d>(args.This());
   rgba_to_string(context->state->stroke, buf, sizeof(buf));
-  NanReturnValue(String::New(buf));
+  NanReturnValue(NanNew<String>(buf));
 }
 
 /*
@@ -1876,7 +1876,7 @@ NAN_METHOD(Context2d::MeasureText) {
   cairo_t *ctx = context->context();
 
   String::Utf8Value str(args[0]->ToString());
-  Local<Object> obj = Object::New();
+  Local<Object> obj = NanNew<Object>();
 
 #if HAVE_PANGO
 
@@ -1917,21 +1917,21 @@ NAN_METHOD(Context2d::MeasureText) {
       y_offset = 0.0;
   }
 
-  obj->Set(String::New("width"), Number::New(logical_rect.width));
-  obj->Set(String::New("actualBoundingBoxLeft"),
-           Number::New(x_offset - PANGO_LBEARING(logical_rect)));
-  obj->Set(String::New("actualBoundingBoxRight"),
-           Number::New(x_offset + PANGO_RBEARING(logical_rect)));
-  obj->Set(String::New("actualBoundingBoxAscent"),
-           Number::New(-(y_offset+ink_rect.y)));
-  obj->Set(String::New("actualBoundingBoxDescent"),
-           Number::New((PANGO_DESCENT(ink_rect) + y_offset)));
-  obj->Set(String::New("emHeightAscent"),
-           Number::New(PANGO_ASCENT(logical_rect) - y_offset));
-  obj->Set(String::New("emHeightDescent"),
-           Number::New(PANGO_DESCENT(logical_rect) + y_offset));
-  obj->Set(String::New("alphabeticBaseline"),
-           Number::New((pango_font_metrics_get_ascent(metrics) / PANGO_SCALE)
+  obj->Set(NanNew<String>("width"), NanNew<Number>(logical_rect.width));
+  obj->Set(NanNew<String>("actualBoundingBoxLeft"),
+           NanNew<Number>(x_offset - PANGO_LBEARING(logical_rect)));
+  obj->Set(NanNew<String>("actualBoundingBoxRight"),
+           NanNew<Number>(x_offset + PANGO_RBEARING(logical_rect)));
+  obj->Set(NanNew<String>("actualBoundingBoxAscent"),
+           NanNew<Number>(-(y_offset+ink_rect.y)));
+  obj->Set(NanNew<String>("actualBoundingBoxDescent"),
+           NanNew<Number>((PANGO_DESCENT(ink_rect) + y_offset)));
+  obj->Set(NanNew<String>("emHeightAscent"),
+           NanNew<Number>(PANGO_ASCENT(logical_rect) - y_offset));
+  obj->Set(NanNew<String>("emHeightDescent"),
+           NanNew<Number>(PANGO_DESCENT(logical_rect) + y_offset));
+  obj->Set(NanNew<String>("alphabeticBaseline"),
+           NanNew<Number>((pango_font_metrics_get_ascent(metrics) / PANGO_SCALE)
                        + y_offset));
 
   pango_font_metrics_unref(metrics);
@@ -1972,18 +1972,18 @@ NAN_METHOD(Context2d::MeasureText) {
       y_offset = 0.0;
   }
 
-  obj->Set(String::New("width"), Number::New(te.x_advance));
-  obj->Set(String::New("actualBoundingBoxLeft"),
-           Number::New(x_offset - te.x_bearing));
-  obj->Set(String::New("actualBoundingBoxRight"),
-           Number::New((te.x_bearing + te.width) - x_offset));
-  obj->Set(String::New("actualBoundingBoxAscent"),
-           Number::New(-(te.y_bearing + y_offset)));
-  obj->Set(String::New("actualBoundingBoxDescent"),
-           Number::New(te.height + te.y_bearing + y_offset));
-  obj->Set(String::New("emHeightAscent"), Number::New(fe.ascent - y_offset));
-  obj->Set(String::New("emHeightDescent"), Number::New(fe.descent + y_offset));
-  obj->Set(String::New("alphabeticBaseline"), Number::New(y_offset));
+  obj->Set(NanNew<String>("width"), NanNew<Number>(te.x_advance));
+  obj->Set(NanNew<String>("actualBoundingBoxLeft"),
+           NanNew<Number>(x_offset - te.x_bearing));
+  obj->Set(NanNew<String>("actualBoundingBoxRight"),
+           NanNew<Number>((te.x_bearing + te.width) - x_offset));
+  obj->Set(NanNew<String>("actualBoundingBoxAscent"),
+           NanNew<Number>(-(te.y_bearing + y_offset)));
+  obj->Set(NanNew<String>("actualBoundingBoxDescent"),
+           NanNew<Number>(te.height + te.y_bearing + y_offset));
+  obj->Set(NanNew<String>("emHeightAscent"), NanNew<Number>(fe.ascent - y_offset));
+  obj->Set(NanNew<String>("emHeightDescent"), NanNew<Number>(fe.descent + y_offset));
+  obj->Set(NanNew<String>("alphabeticBaseline"), NanNew<Number>(y_offset));
 
 #endif
 
diff --git a/src/FontFace.cc b/src/FontFace.cc
index af867a8..d7d1be6 100644
--- a/src/FontFace.cc
+++ b/src/FontFace.cc
@@ -30,8 +30,8 @@ FontFace::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(FontFace::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(FontFace::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("FontFace"));
 
diff --git a/src/Image.cc b/src/Image.cc
index 79ada71..bb7ba75 100644
--- a/src/Image.cc
+++ b/src/Image.cc
@@ -38,8 +38,8 @@ void
 Image::Initialize(Handle<Object> target) {
   NanScope();
 
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(Image::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Image::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("Image"));
 
@@ -56,8 +56,8 @@ Image::Initialize(Handle<Object> target) {
   proto->SetAccessor(NanSymbol("onerror"), GetOnerror, SetOnerror);
 #if CAIRO_VERSION_MINOR >= 10
   proto->SetAccessor(NanSymbol("dataMode"), GetDataMode, SetDataMode);
-  ctor->Set(NanSymbol("MODE_IMAGE"), Number::New(DATA_IMAGE));
-  ctor->Set(NanSymbol("MODE_MIME"), Number::New(DATA_MIME));
+  ctor->Set(NanSymbol("MODE_IMAGE"), NanNew<Number>(DATA_IMAGE));
+  ctor->Set(NanSymbol("MODE_MIME"), NanNew<Number>(DATA_MIME));
 #endif
   target->Set(NanSymbol("Image"), ctor->GetFunction());
 }
@@ -81,7 +81,7 @@ NAN_METHOD(Image::New) {
 NAN_GETTER(Image::GetComplete) {
   NanScope();
   Image *img = ObjectWrap::Unwrap<Image>(args.This());
-  NanReturnValue(Boolean::New(Image::COMPLETE == img->state));
+  NanReturnValue(NanNew<Boolean>(Image::COMPLETE == img->state));
 }
 
 #if CAIRO_VERSION_MINOR >= 10
@@ -93,7 +93,7 @@ NAN_GETTER(Image::GetComplete) {
 NAN_GETTER(Image::GetDataMode) {
   NanScope();
   Image *img = ObjectWrap::Unwrap<Image>(args.This());
-  NanReturnValue(Number::New(img->data_mode));
+  NanReturnValue(NanNew<Number>(img->data_mode));
 }
 
 /*
@@ -117,7 +117,7 @@ NAN_SETTER(Image::SetDataMode) {
 NAN_GETTER(Image::GetWidth) {
   NanScope();
   Image *img = ObjectWrap::Unwrap<Image>(args.This());
-  NanReturnValue(Number::New(img->width));
+  NanReturnValue(NanNew<Number>(img->width));
 }
 /*
  * Get height.
@@ -126,7 +126,7 @@ NAN_GETTER(Image::GetWidth) {
 NAN_GETTER(Image::GetHeight) {
   NanScope();
   Image *img = ObjectWrap::Unwrap<Image>(args.This());
-  NanReturnValue(Number::New(img->height));
+  NanReturnValue(NanNew<Number>(img->height));
 }
 
 /*
@@ -136,7 +136,7 @@ NAN_GETTER(Image::GetHeight) {
 NAN_GETTER(Image::GetSource) {
   NanScope();
   Image *img = ObjectWrap::Unwrap<Image>(args.This());
-  NanReturnValue(String::New(img->filename ? img->filename : ""));
+  NanReturnValue(NanNew<String>(img->filename ? img->filename : ""));
 }
 
 /*
@@ -147,7 +147,7 @@ void
 Image::clearData() {
   if (_surface) {
     cairo_surface_destroy(_surface);
-    V8::AdjustAmountOfExternalAllocatedMemory(-_data_len);
+    NanAdjustExternalMemory(-_data_len);
     _data_len = 0;
     _surface = NULL;
   }
@@ -359,7 +359,7 @@ Image::loaded() {
   width = cairo_image_surface_get_width(_surface);
   height = cairo_image_surface_get_height(_surface);
   _data_len = height * cairo_image_surface_get_stride(_surface);
-  V8::AdjustAmountOfExternalAllocatedMemory(_data_len);
+  NanAdjustExternalMemory(_data_len);
 
   if (onload != NULL) {
     onload->Call(0, NULL);
@@ -807,7 +807,7 @@ Image::decodeJPEGBufferIntoMimeSurface(uint8_t *buf, unsigned len) {
 
 void
 clearMimeData(void *closure) {
-  V8::AdjustAmountOfExternalAllocatedMemory(-((read_closure_t *)closure)->len);
+  NanAdjustExternalMemory(-((read_closure_t *)closure)->len);
   free(((read_closure_t *) closure)->buf);
   free(closure);
 }
@@ -834,7 +834,7 @@ Image::assignDataAsMime(uint8_t *data, int len, const char *mime_type) {
   mime_closure->buf = mime_data;
   mime_closure->len = len;
 
-  V8::AdjustAmountOfExternalAllocatedMemory(len);
+  NanAdjustExternalMemory(len);
 
   return cairo_surface_set_mime_data(_surface
     , mime_type
diff --git a/src/ImageData.cc b/src/ImageData.cc
index 0694917..aa1a594 100644
--- a/src/ImageData.cc
+++ b/src/ImageData.cc
@@ -18,8 +18,8 @@ ImageData::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(ImageData::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(ImageData::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("ImageData"));
 
@@ -55,7 +55,7 @@ NAN_METHOD(ImageData::New) {
 NAN_GETTER(ImageData::GetWidth) {
   NanScope();
   ImageData *imageData = ObjectWrap::Unwrap<ImageData>(args.This());
-  NanReturnValue(Number::New(imageData->pixelArray()->width()));
+  NanReturnValue(NanNew<Number>(imageData->pixelArray()->width()));
 }
 
 /*
@@ -65,5 +65,5 @@ NAN_GETTER(ImageData::GetWidth) {
 NAN_GETTER(ImageData::GetHeight) {
   NanScope();
   ImageData *imageData = ObjectWrap::Unwrap<ImageData>(args.This());
-  NanReturnValue(Number::New(imageData->pixelArray()->height()));
+  NanReturnValue(NanNew<Number>(imageData->pixelArray()->height()));
 }
diff --git a/src/JPEGStream.h b/src/JPEGStream.h
index 3f21a9c..e3efcc6 100644
--- a/src/JPEGStream.h
+++ b/src/JPEGStream.h
@@ -34,11 +34,11 @@ empty_closure_output_buffer(j_compress_ptr cinfo){
   closure_destination_mgr *dest = (closure_destination_mgr *) cinfo->dest;
   Local<Object> buf = NanNewBufferHandle((char *)dest->buffer, dest->bufsize);
   Local<Value> argv[3] = {
-      NanNewLocal<Value>(Null())
-    , NanNewLocal<Value>(buf)
-    , Integer::New(dest->bufsize)
+      NanNull()
+    , NanNew<Value>(buf)
+    , NanNew<Integer>(dest->bufsize)
   };
-  dest->closure->fn->Call(Context::GetCurrent()->Global(), 3, argv);
+  NanMakeCallback(NanGetCurrentContext(), dest->closure->fn, 3, argv);
   cinfo->dest->next_output_byte = dest->buffer;
   cinfo->dest->free_in_buffer = dest->bufsize;
   return true;
@@ -53,21 +53,21 @@ term_closure_destination(j_compress_ptr cinfo){
   Local<Object> buf = NanNewBufferHandle((char *)dest->buffer, remaining);
 
   Local<Value> data_argv[3] = {
-      NanNewLocal<Value>(Null())
-    , NanNewLocal<Value>(buf)
-    , Integer::New(remaining)
+      NanNull()
+    , NanNew<Value>(buf)
+    , NanNew<Integer>(remaining)
   };
 
-  dest->closure->fn->Call(Context::GetCurrent()->Global(), 3, data_argv);
+  NanMakeCallback(NanGetCurrentContext(), dest->closure->fn, 3, data_argv);
 
   // emit "end"
   Local<Value> end_argv[3] = {
-      NanNewLocal<Value>(Null())
-    , NanNewLocal<Value>(Null())
-    , Integer::New(0)
+      NanNull()
+    , NanNull()
+    , NanNew<Integer>(0)
   };
 
-  dest->closure->fn->Call(Context::GetCurrent()->Global(), 3, end_argv);
+  NanMakeCallback(NanGetCurrentContext(), dest->closure->fn, 3, end_argv);
 }
 
 void
diff --git a/src/PixelArray.cc b/src/PixelArray.cc
index 4abc181..2bfe82e 100644
--- a/src/PixelArray.cc
+++ b/src/PixelArray.cc
@@ -22,8 +22,8 @@ PixelArray::Initialize(Handle<Object> target) {
   NanScope();
 
   // Constructor
-  Local<FunctionTemplate> ctor = FunctionTemplate::New(PixelArray::New);
-  NanAssignPersistent(FunctionTemplate, constructor, ctor);
+  Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(PixelArray::New);
+  NanAssignPersistent(constructor, ctor);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(NanSymbol("CanvasPixelArray"));
 
@@ -82,7 +82,7 @@ NAN_METHOD(PixelArray::New) {
 
 NAN_GETTER(PixelArray::GetLength) {
   NanScope();
-  NanReturnValue(Number::New(args.This()->GetIndexedPropertiesPixelDataLength()));
+  NanReturnValue(NanNew<Number>(args.This()->GetIndexedPropertiesPixelDataLength()));
 }
 
 /*
@@ -142,7 +142,7 @@ uint8_t *
 PixelArray::alloc() {
   int len = length();
   _data = (uint8_t *) calloc(1, len);
-  V8::AdjustAmountOfExternalAllocatedMemory(len);
+  NanAdjustExternalMemory(len);
   return _data;
 }
 
@@ -151,6 +151,6 @@ PixelArray::alloc() {
  */
 
 PixelArray::~PixelArray() {
-  V8::AdjustAmountOfExternalAllocatedMemory(-length());
+  NanAdjustExternalMemory(-length());
   free(_data);
 }
diff --git a/src/closure.h b/src/closure.h
index 1b3147b..96dcb9d 100644
--- a/src/closure.h
+++ b/src/closure.h
@@ -58,7 +58,7 @@ void
 closure_destroy(closure_t *closure) {
   if (closure->len) {
     free(closure->data);
-    V8::AdjustAmountOfExternalAllocatedMemory(- (intptr_t) closure->max_len);
+    NanAdjustExternalMemory(- (intptr_t) closure->max_len);
   }
 }
 
diff --git a/src/init.cc b/src/init.cc
index f7c822d..6628cee 100755
--- a/src/init.cc
+++ b/src/init.cc
@@ -32,7 +32,7 @@ init (Handle<Object> target) {
   FontFace::Initialize(target);
 #endif
 
-  target->Set(String::New("cairoVersion"), String::New(cairo_version_string()));
+  target->Set(NanNew<String>("cairoVersion"), NanNew<String>(cairo_version_string()));
 #ifdef HAVE_JPEG
 
 #ifndef JPEG_LIB_VERSION_MAJOR
@@ -57,16 +57,16 @@ init (Handle<Object> target) {
   } else {
     snprintf(jpeg_version, 10, "%d", JPEG_LIB_VERSION_MAJOR);
   }
-  target->Set(String::New("jpegVersion"), String::New(jpeg_version));
+  target->Set(NanNew<String>("jpegVersion"), NanNew<String>(jpeg_version));
 #endif
 
 #ifdef HAVE_GIF
 #ifndef GIF_LIB_VERSION
   char gif_version[10];
   snprintf(gif_version, 10, "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR, GIFLIB_RELEASE);
-  target->Set(String::New("gifVersion"), String::New(gif_version));
+  target->Set(NanNew<String>("gifVersion"), NanNew<String>(gif_version));
 #else
-  target->Set(String::New("gifVersion"), String::New(GIF_LIB_VERSION));
+  target->Set(NanNew<String>("gifVersion"), NanNew<String>(GIF_LIB_VERSION));
 #endif
 #endif
 }