From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Wed, 7 Aug 2013 19:50:41 +0000 (+0200)
Subject: src: use v8::String::NewFrom*() functions
X-Git-Tag: v0.11.6~77
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=f674b09f40d22915e15b6968aafc5d25ac8178a2;p=platform%2Fupstream%2Fnodejs.git

src: use v8::String::NewFrom*() functions

* Change calls to String::New() and String::NewSymbol() to their
  respective one-byte, two-byte and UTF-8 counterparts.

* Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and
  turns it into a v8::Local<v8::String>.

* Add helper functions that make v8::String::NewFromOneByte() easier to
  work with. Said function expects a `const uint8_t*` but almost every
  call site deals with `const char*` or `const unsigned char*`. Helps
  us avoid doing reinterpret_casts all over the place.

* Code that handles file system paths keeps using UTF-8 for backwards
  compatibility reasons. At least now the use of UTF-8 is explicit.

* Remove v8::String::NewSymbol() entirely. Almost all call sites were
  effectively minor de-optimizations. If you create a string only once,
  there is no point in making it a symbol. If you are create the same
  string repeatedly, it should probably be cached in a persistent
  handle.
---

diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index d782ad6..746dc02 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -206,7 +206,7 @@ static Local<Array> HostentToAddresses(struct hostent* host) {
   for (int i = 0; host->h_addr_list[i]; ++i) {
     uv_inet_ntop(host->h_addrtype, host->h_addr_list[i], ip, sizeof(ip));
 
-    Local<String> address = String::New(ip);
+    Local<String> address = OneByteString(node_isolate, ip);
     addresses->Set(Integer::New(i, node_isolate), address);
   }
 
@@ -219,7 +219,7 @@ static Local<Array> HostentToNames(struct hostent* host) {
   Local<Array> names = Array::New();
 
   for (int i = 0; host->h_aliases[i]; ++i) {
-    Local<String> address = String::New(host->h_aliases[i]);
+    Local<String> address = OneByteString(node_isolate, host->h_aliases[i]);
     names->Set(Integer::New(i, node_isolate), address);
   }
 
@@ -426,7 +426,7 @@ class QueryCnameWrap: public QueryWrap {
     // A cname lookup always returns a single record but we follow the
     // common API here.
     Local<Array> result = Array::New(1);
-    result->Set(0, String::New(host->h_name));
+    result->Set(0, OneByteString(node_isolate, host->h_name));
     ares_free_hostent(host);
 
     this->CallOnComplete(result);
@@ -456,14 +456,18 @@ class QueryMxWrap: public QueryWrap {
     }
 
     Local<Array> mx_records = Array::New();
-    Local<String> exchange_symbol = String::NewSymbol("exchange");
-    Local<String> priority_symbol = String::NewSymbol("priority");
+    Local<String> exchange_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "exchange");
+    Local<String> priority_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "priority");
+
     int i = 0;
     for (struct ares_mx_reply* mx_current = mx_start;
          mx_current;
          mx_current = mx_current->next) {
       Local<Object> mx_record = Object::New();
-      mx_record->Set(exchange_symbol, String::New(mx_current->host));
+      mx_record->Set(exchange_symbol,
+                     OneByteString(node_isolate, mx_current->host));
       mx_record->Set(priority_symbol,
                      Integer::New(mx_current->priority, node_isolate));
       mx_records->Set(Integer::New(i++, node_isolate), mx_record);
@@ -528,7 +532,7 @@ class QueryTxtWrap: public QueryWrap {
 
     struct ares_txt_reply *current = txt_out;
     for (int i = 0; current; ++i, current = current->next) {
-      Local<String> txt = String::New(reinterpret_cast<char*>(current->txt));
+      Local<String> txt = OneByteString(node_isolate, current->txt);
       txt_records->Set(Integer::New(i, node_isolate), txt);
     }
 
@@ -566,16 +570,22 @@ class QuerySrvWrap: public QueryWrap {
     }
 
     Local<Array> srv_records = Array::New();
-    Local<String> name_symbol = String::NewSymbol("name");
-    Local<String> port_symbol = String::NewSymbol("port");
-    Local<String> priority_symbol = String::NewSymbol("priority");
-    Local<String> weight_symbol = String::NewSymbol("weight");
+    Local<String> name_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "name");
+    Local<String> port_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "port");
+    Local<String> priority_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "priority");
+    Local<String> weight_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "weight");
+
     int i = 0;
     for (struct ares_srv_reply* srv_current = srv_start;
          srv_current;
          srv_current = srv_current->next) {
       Local<Object> srv_record = Object::New();
-      srv_record->Set(name_symbol, String::New(srv_current->host));
+      srv_record->Set(name_symbol,
+                      OneByteString(node_isolate, srv_current->host));
       srv_record->Set(port_symbol,
                       Integer::New(srv_current->port, node_isolate));
       srv_record->Set(priority_symbol,
@@ -620,12 +630,18 @@ class QueryNaptrWrap: public QueryWrap {
     }
 
     Local<Array> naptr_records = Array::New();
-    Local<String> flags_symbol = String::NewSymbol("flags");
-    Local<String> service_symbol = String::NewSymbol("service");
-    Local<String> regexp_symbol = String::NewSymbol("regexp");
-    Local<String> replacement_symbol = String::NewSymbol("replacement");
-    Local<String> order_symbol = String::NewSymbol("order");
-    Local<String> preference_symbol = String::NewSymbol("preference");
+    Local<String> flags_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "flags");
+    Local<String> service_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "service");
+    Local<String> regexp_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "regexp");
+    Local<String> replacement_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "replacement");
+    Local<String> order_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "order");
+    Local<String> preference_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "preference");
 
     int i = 0;
     for (ares_naptr_reply* naptr_current = naptr_start;
@@ -634,13 +650,14 @@ class QueryNaptrWrap: public QueryWrap {
       Local<Object> naptr_record = Object::New();
 
       naptr_record->Set(flags_symbol,
-          String::New(reinterpret_cast<char*>(naptr_current->flags)));
+                        OneByteString(node_isolate, naptr_current->flags));
       naptr_record->Set(service_symbol,
-          String::New(reinterpret_cast<char*>(naptr_current->service)));
+                        OneByteString(node_isolate, naptr_current->service));
       naptr_record->Set(regexp_symbol,
-          String::New(reinterpret_cast<char*>(naptr_current->regexp)));
+                        OneByteString(node_isolate, naptr_current->regexp));
       naptr_record->Set(replacement_symbol,
-          String::New(naptr_current->replacement));
+                        OneByteString(node_isolate,
+                                      naptr_current->replacement));
       naptr_record->Set(order_symbol, Integer::New(naptr_current->order,
                                                    node_isolate));
       naptr_record->Set(preference_symbol,
@@ -814,7 +831,7 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
           continue;
 
         // Create JavaScript string
-        Local<String> s = String::New(ip);
+        Local<String> s = OneByteString(node_isolate, ip);
         results->Set(n, s);
         n++;
       }
@@ -841,7 +858,7 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
           continue;
 
         // Create JavaScript string
-        Local<String> s = String::New(ip);
+        Local<String> s = OneByteString(node_isolate, ip);
         results->Set(n, s);
         n++;
       }
@@ -943,7 +960,7 @@ static void GetServers(const FunctionCallbackInfo<Value>& args) {
     int err = uv_inet_ntop(cur->family, caddr, ip, sizeof(ip));
     assert(err == 0);
 
-    Local<String> addr = String::New(ip);
+    Local<String> addr = OneByteString(node_isolate, ip);
     server_array->Set(i, addr);
   }
 
@@ -1024,7 +1041,7 @@ static void SetServers(const FunctionCallbackInfo<Value>& args) {
 static void StrError(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
   const char* errmsg = ares_strerror(args[0]->Int32Value());
-  args.GetReturnValue().Set(String::New(errmsg));
+  args.GetReturnValue().Set(OneByteString(node_isolate, errmsg));
 }
 
 
@@ -1069,14 +1086,14 @@ static void Initialize(Handle<Object> target) {
   NODE_SET_METHOD(target, "getServers", GetServers);
   NODE_SET_METHOD(target, "setServers", SetServers);
 
-  target->Set(String::NewSymbol("AF_INET"),
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_INET"),
               Integer::New(AF_INET, node_isolate));
-  target->Set(String::NewSymbol("AF_INET6"),
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_INET6"),
               Integer::New(AF_INET6, node_isolate));
-  target->Set(String::NewSymbol("AF_UNSPEC"),
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_UNSPEC"),
               Integer::New(AF_UNSPEC, node_isolate));
 
-  oncomplete_sym = String::New("oncomplete");
+  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 }
 
 }  // namespace cares_wrap
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index b8d24c0..8c10cca 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -75,16 +75,16 @@ void FSEventWrap::Initialize(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("FSEvent"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "FSEvent"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "start", Start);
   NODE_SET_PROTOTYPE_METHOD(t, "close", Close);
 
-  target->Set(String::New("FSEvent"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "FSEvent"), t->GetFunction());
 
-  change_sym = String::New("change");
-  onchange_sym = String::New("onchange");
-  rename_sym = String::New("rename");
+  change_sym = FIXED_ONE_BYTE_STRING(node_isolate, "change");
+  onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
+  rename_sym = FIXED_ONE_BYTE_STRING(node_isolate, "rename");
 }
 
 
@@ -161,7 +161,7 @@ void FSEventWrap::OnEvent(uv_fs_event_t* handle, const char* filename,
   };
 
   if (filename != NULL) {
-    argv[2] = String::New(filename);
+    argv[2] = OneByteString(node_isolate, filename);
   }
 
   MakeCallback(wrap->object(), onchange_sym, ARRAY_SIZE(argv), argv);
diff --git a/src/handle_wrap.cc b/src/handle_wrap.cc
index 1eb0dc5..ce6ac5c 100644
--- a/src/handle_wrap.cc
+++ b/src/handle_wrap.cc
@@ -76,7 +76,9 @@ void HandleWrap::Close(const FunctionCallbackInfo<Value>& args) {
   wrap->handle__ = NULL;
 
   if (args[0]->IsFunction()) {
-    if (close_sym.IsEmpty() == true) close_sym = String::New("close");
+    if (close_sym.IsEmpty() == true) {
+      close_sym = FIXED_ONE_BYTE_STRING(node_isolate, "close");
+    }
     wrap->object()->Set(close_sym, args[0]);
     wrap->flags_ |= kCloseCallback;
   }
diff --git a/src/node.cc b/src/node.cc
index 649fd92..8c1653a 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -242,7 +242,8 @@ static void CheckImmediate(uv_check_t* handle, int status) {
   HandleScope scope(node_isolate);
 
   if (immediate_callback_sym.IsEmpty()) {
-    immediate_callback_sym = String::New("_immediateCallback");
+    immediate_callback_sym =
+        FIXED_ONE_BYTE_STRING(node_isolate, "_immediateCallback");
   }
 
   MakeCallback(process_p, immediate_callback_sym, 0, NULL);
@@ -738,26 +739,30 @@ Local<Value> ErrnoException(int errorno,
                             const char *msg,
                             const char *path) {
   Local<Value> e;
-  Local<String> estring = String::NewSymbol(errno_string(errorno));
+  Local<String> estring = OneByteString(node_isolate, errno_string(errorno));
   if (msg == NULL || msg[0] == '\0') {
     msg = strerror(errorno);
   }
-  Local<String> message = String::NewSymbol(msg);
+  Local<String> message = OneByteString(node_isolate, msg);
 
-  Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));
+  Local<String> cons1 =
+      String::Concat(estring, FIXED_ONE_BYTE_STRING(node_isolate, ", "));
   Local<String> cons2 = String::Concat(cons1, message);
 
   if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = String::New("syscall");
-    errno_symbol = String::New("errno");
-    errpath_symbol = String::New("path");
-    code_symbol = String::New("code");
+    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
   }
 
   if (path) {
-    Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));
-    Local<String> cons4 = String::Concat(cons3, String::New(path));
-    Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));
+    Local<String> cons3 =
+        String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+    Local<String> cons4 =
+        String::Concat(cons3, String::NewFromUtf8(node_isolate, path));
+    Local<String> cons5 =
+        String::Concat(cons4, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
     e = Exception::Error(cons5);
   } else {
     e = Exception::Error(cons2);
@@ -767,8 +772,8 @@ Local<Value> ErrnoException(int errorno,
 
   obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
   obj->Set(code_symbol, estring);
-  if (path) obj->Set(errpath_symbol, String::New(path));
-  if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+  if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
+  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
   return e;
 }
 
@@ -779,18 +784,19 @@ Local<Value> UVException(int errorno,
                          const char *msg,
                          const char *path) {
   if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = String::New("syscall");
-    errno_symbol = String::New("errno");
-    errpath_symbol = String::New("path");
-    code_symbol = String::New("code");
+    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
   }
 
   if (!msg || !msg[0])
     msg = uv_strerror(errorno);
 
-  Local<String> estring = String::NewSymbol(uv_err_name(errorno));
-  Local<String> message = String::NewSymbol(msg);
-  Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));
+  Local<String> estring = OneByteString(node_isolate, uv_err_name(errorno));
+  Local<String> message = OneByteString(node_isolate, msg);
+  Local<String> cons1 =
+      String::Concat(estring, FIXED_ONE_BYTE_STRING(node_isolate, ", "));
   Local<String> cons2 = String::Concat(cons1, message);
 
   Local<Value> e;
@@ -800,19 +806,23 @@ Local<Value> UVException(int errorno,
   if (path) {
 #ifdef _WIN32
     if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {
-      path_str = String::Concat(String::New("\\\\"), String::New(path + 8));
+      path_str = String::Concat(FIXED_ONE_BYTE_STRING(node_isolate, "\\\\"),
+                                String::NewFromUtf8(node_isolate, path + 8));
     } else if (strncmp(path, "\\\\?\\", 4) == 0) {
-      path_str = String::New(path + 4);
+      path_str = String::NewFromUtf8(node_isolate, path + 4);
     } else {
-      path_str = String::New(path);
+      path_str = String::NewFromUtf8(node_isolate, path);
     }
 #else
-    path_str = String::New(path);
+    path_str = String::NewFromUtf8(node_isolate, path);
 #endif
 
-    Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));
-    Local<String> cons4 = String::Concat(cons3, path_str);
-    Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));
+    Local<String> cons3 =
+        String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+    Local<String> cons4 =
+        String::Concat(cons3, path_str);
+    Local<String> cons5 =
+        String::Concat(cons4, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
     e = Exception::Error(cons5);
   } else {
     e = Exception::Error(cons2);
@@ -824,7 +834,7 @@ Local<Value> UVException(int errorno,
   obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
   obj->Set(code_symbol, estring);
   if (path) obj->Set(errpath_symbol, path_str);
-  if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
   return e;
 }
 
@@ -862,19 +872,22 @@ Local<Value> WinapiErrnoException(int errorno,
   if (!msg || !msg[0]) {
     msg = winapi_strerror(errorno);
   }
-  Local<String> message = String::NewSymbol(msg);
+  Local<String> message = OneByteString(node_isolate, msg);
 
   if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = String::New("syscall");
-    errno_symbol = String::New("errno");
-    errpath_symbol = String::New("path");
-    code_symbol = String::New("code");
+    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
+    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
+    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
+    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
   }
 
   if (path) {
-    Local<String> cons1 = String::Concat(message, String::NewSymbol(" '"));
-    Local<String> cons2 = String::Concat(cons1, String::New(path));
-    Local<String> cons3 = String::Concat(cons2, String::NewSymbol("'"));
+    Local<String> cons1 =
+        String::Concat(message, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
+    Local<String> cons2 =
+        String::Concat(cons1, String::NewFromUtf8(node_isolate, path));
+    Local<String> cons3 =
+        String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, "'"));
     e = Exception::Error(cons3);
   } else {
     e = Exception::Error(message);
@@ -883,8 +896,8 @@ Local<Value> WinapiErrnoException(int errorno,
   Local<Object> obj = e->ToObject();
 
   obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
-  if (path) obj->Set(errpath_symbol, String::New(path));
-  if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));
+  if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
+  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
   return e;
 }
 #endif
@@ -895,8 +908,10 @@ void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
   using_domains = true;
   Local<Object> process = PersistentToLocal(node_isolate, process_p);
-  Local<Value> tdc_v = process->Get(String::New("_tickDomainCallback"));
-  Local<Value> ndt_v = process->Get(String::New("_nextDomainTick"));
+  Local<Value> tdc_v =
+      process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickDomainCallback"));
+  Local<Value> ndt_v =
+      process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_nextDomainTick"));
   if (!tdc_v->IsFunction()) {
     fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");
     abort();
@@ -907,8 +922,8 @@ void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
   }
   Local<Function> tdc = tdc_v.As<Function>();
   Local<Function> ndt = ndt_v.As<Function>();
-  process->Set(String::New("_tickCallback"), tdc);
-  process->Set(String::New("nextTick"), ndt);
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"), tdc);
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "nextTick"), ndt);
   process_tickCallback.Reset(node_isolate, tdc);
 }
 
@@ -922,9 +937,9 @@ MakeDomainCallback(const Handle<Object> object,
 
   // lazy load domain specific symbols
   if (enter_symbol.IsEmpty()) {
-    enter_symbol = String::New("enter");
-    exit_symbol = String::New("exit");
-    disposed_symbol = String::New("_disposed");
+    enter_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "enter");
+    exit_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exit");
+    disposed_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "_disposed");
   }
 
   Local<Value> domain_v = object->Get(domain_symbol);
@@ -1008,7 +1023,8 @@ MakeCallback(const Handle<Object> object,
 
   // lazy load no domain next tick callbacks
   if (process_tickCallback.IsEmpty()) {
-    Local<Value> cb_v = process->Get(String::New("_tickCallback"));
+    Local<Value> cb_v =
+        process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"));
     if (!cb_v->IsFunction()) {
       fprintf(stderr, "process._tickCallback assigned to non-function\n");
       abort();
@@ -1069,8 +1085,8 @@ MakeCallback(const Handle<Object> object,
              Handle<Value> argv[]) {
   HandleScope scope(node_isolate);
 
-  Handle<Value> ret =
-    MakeCallback(object, String::NewSymbol(method), argc, argv);
+  Local<String> method_string = OneByteString(node_isolate, method);
+  Handle<Value> ret = MakeCallback(object, method_string, argc, argv);
 
   return scope.Close(ret);
 }
@@ -1219,7 +1235,8 @@ static void ReportException(Handle<Value> er, Handle<Message> message) {
 
   DisplayExceptionLine(message);
 
-  Local<Value> trace_value(er->ToObject()->Get(String::New("stack")));
+  Local<Value> trace_value(
+      er->ToObject()->Get(FIXED_ONE_BYTE_STRING(node_isolate, "stack")));
   String::Utf8Value trace(trace_value);
 
   // range errors have a trace member set to undefined
@@ -1229,18 +1246,27 @@ static void ReportException(Handle<Value> er, Handle<Message> message) {
     // this really only happens for RangeErrors, since they're the only
     // kind that won't have all this info in the trace, or when non-Error
     // objects are thrown manually.
-    bool isErrorObject = er->IsObject() &&
-      !(er->ToObject()->Get(String::New("message"))->IsUndefined()) &&
-      !(er->ToObject()->Get(String::New("name"))->IsUndefined());
+    Local<Value> message;
+    Local<Value> name;
 
-    if (isErrorObject) {
-      String::Utf8Value name(er->ToObject()->Get(String::New("name")));
-      fprintf(stderr, "%s: ", *name);
+    if (er->IsObject()) {
+      Local<Object> err_obj = er.As<Object>();
+      message = err_obj->Get(FIXED_ONE_BYTE_STRING(node_isolate, "message"));
+      name = err_obj->Get(FIXED_ONE_BYTE_STRING(node_isolate, "name"));
     }
 
-    String::Utf8Value msg(!isErrorObject ? er
-                         : er->ToObject()->Get(String::New("message")));
-    fprintf(stderr, "%s\n", *msg);
+    if (message.IsEmpty() ||
+        message->IsUndefined() ||
+        name.IsEmpty() ||
+        name->IsUndefined()) {
+      // Not an error object. Just print as-is.
+      String::Utf8Value message(er);
+      fprintf(stderr, "%s\n", *message);
+    } else {
+      String::Utf8Value name_string(name);
+      String::Utf8Value message_string(message);
+      fprintf(stderr, "%s: %s\n", *name_string, *message_string);
+    }
   }
 
   fflush(stderr);
@@ -1303,7 +1329,7 @@ void GetActiveHandles(const FunctionCallbackInfo<Value>& args) {
   QUEUE* q = NULL;
   int i = 0;
 
-  Local<String> owner_sym = String::New("owner");
+  Local<String> owner_sym = FIXED_ONE_BYTE_STRING(node_isolate, "owner");
 
   QUEUE_FOREACH(q, &handle_wrap_queue) {
     HandleWrap* w = container_of(q, HandleWrap, handle_wrap_queue_);
@@ -1353,7 +1379,7 @@ static void Cwd(const FunctionCallbackInfo<Value>& args) {
   }
 
   buf[ARRAY_SIZE(buf) - 1] = '\0';
-  Local<String> cwd = String::New(buf);
+  Local<String> cwd = String::NewFromUtf8(node_isolate, buf);
 
   args.GetReturnValue().Set(cwd);
 }
@@ -1687,9 +1713,9 @@ void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
   Local<Object> info = Object::New();
 
   if (rss_symbol.IsEmpty()) {
-    rss_symbol = String::New("rss");
-    heap_total_symbol = String::New("heapTotal");
-    heap_used_symbol = String::New("heapUsed");
+    rss_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rss");
+    heap_total_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapTotal");
+    heap_used_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapUsed");
   }
 
   info->Set(rss_symbol, Number::New(rss));
@@ -1770,12 +1796,12 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
   String::Utf8Value filename(args[1]);  // Cast
 
   if (exports_symbol.IsEmpty()) {
-    exports_symbol = String::New("exports");
+    exports_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exports");
   }
   Local<Object> exports = module->Get(exports_symbol)->ToObject();
 
   if (uv_dlopen(*filename, &lib)) {
-    Local<String> errmsg = String::New(uv_dlerror(&lib));
+    Local<String> errmsg = OneByteString(node_isolate, uv_dlerror(&lib));
 #ifdef _WIN32
     // Windows needs to add the filename into the error message
     errmsg = String::Concat(errmsg, args[1]->ToString());
@@ -1870,8 +1896,10 @@ NO_RETURN void FatalError(const char* location, const char* message) {
 void FatalException(Handle<Value> error, Handle<Message> message) {
   HandleScope scope(node_isolate);
 
-  if (fatal_exception_symbol.IsEmpty())
-    fatal_exception_symbol = String::New("_fatalException");
+  if (fatal_exception_symbol.IsEmpty()) {
+    fatal_exception_symbol =
+        FIXED_ONE_BYTE_STRING(node_isolate, "_fatalException");
+  }
 
   Local<Object> process = PersistentToLocal(node_isolate, process_p);
   Local<Value> fatal_v = process->Get(fatal_exception_symbol);
@@ -1943,7 +1971,7 @@ static void Binding(const FunctionCallbackInfo<Value>& args) {
 
   Local<Array> modules = PersistentToLocal(node_isolate, module_load_list);
   uint32_t l = modules->Length();
-  modules->Set(l, String::New(buf));
+  modules->Set(l, OneByteString(node_isolate, buf));
 
   if ((modp = get_builtin_module(*module_v)) != NULL) {
     exports = Object::New();
@@ -1972,7 +2000,7 @@ static void ProcessTitleGetter(Local<String> property,
   HandleScope scope(node_isolate);
   char buffer[512];
   uv_get_process_title(buffer, sizeof(buffer));
-  info.GetReturnValue().Set(String::New(buffer));
+  info.GetReturnValue().Set(String::NewFromUtf8(node_isolate, buffer));
 }
 
 
@@ -1993,7 +2021,7 @@ static void EnvGetter(Local<String> property,
   String::Utf8Value key(property);
   const char* val = getenv(*key);
   if (val) {
-    return info.GetReturnValue().Set(String::New(val));
+    return info.GetReturnValue().Set(String::NewFromUtf8(node_isolate, val));
   }
 #else  // _WIN32
   String::Value key(property);
@@ -2006,8 +2034,9 @@ static void EnvGetter(Local<String> property,
   // not found.
   if ((result > 0 || GetLastError() == ERROR_SUCCESS) &&
       result < ARRAY_SIZE(buffer)) {
-    return info.GetReturnValue().Set(
-        String::New(reinterpret_cast<uint16_t*>(buffer), result));
+    const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(buffer);
+    Local<String> rc = String::NewFromTwoByte(node_isolate, two_byte_buffer);
+    return info.GetReturnValue().Set(rc);
   }
 #endif
   // Not found.  Fetch from prototype.
@@ -2097,7 +2126,11 @@ static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
     const char* var = environ[i];
     const char* s = strchr(var, '=');
     const int length = s ? s - var : strlen(var);
-    env->Set(i, String::New(var, length));
+    Local<String> name = String::NewFromUtf8(node_isolate,
+                                             var,
+                                             String::kNormalString,
+                                             length);
+    env->Set(i, name);
   }
 #else  // _WIN32
   WCHAR* environment = GetEnvironmentStringsW();
@@ -2117,7 +2150,8 @@ static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
     if (!s) {
       s = p + wcslen(p);
     }
-    env->Set(i++, String::New(reinterpret_cast<uint16_t*>(p), s - p));
+    const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(p);
+    env->Set(i++, TWO_BYTE_STRING(node_isolate, two_byte_buffer, s - p));
     p = s + wcslen(s) + 1;
   }
   FreeEnvironmentStringsW(environment);
@@ -2137,15 +2171,18 @@ static Handle<Object> GetFeatures() {
   Local<Value> debug = False(node_isolate);
 #endif  // defined(DEBUG) && DEBUG
 
-  obj->Set(String::NewSymbol("debug"), debug);
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "debug"), debug);
 
-  obj->Set(String::NewSymbol("uv"), True(node_isolate));
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "uv"), True(node_isolate));
   // TODO(bnoordhuis) ping libuv
-  obj->Set(String::NewSymbol("ipv6"), True(node_isolate));
-  obj->Set(String::NewSymbol("tls_npn"), Boolean::New(use_npn));
-  obj->Set(String::NewSymbol("tls_sni"), Boolean::New(use_sni));
-  obj->Set(String::NewSymbol("tls"),
-      Boolean::New(get_builtin_module("crypto") != NULL));
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ipv6"), True(node_isolate));
+
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls_npn"),
+           Boolean::New(use_npn));
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls_sni"),
+           Boolean::New(use_sni));
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "tls"),
+           Boolean::New(get_builtin_module("crypto") != NULL));
 
   return scope.Close(obj);
 }
@@ -2201,7 +2238,7 @@ static void NeedImmediateCallbackSetter(Local<String> property,
 
 #define READONLY_PROPERTY(obj, str, var)                                      \
   do {                                                                        \
-    obj->Set(String::New(str), var, v8::ReadOnly);                            \
+    obj->Set(OneByteString(node_isolate, str), var, v8::ReadOnly);            \
   } while (0)
 
 
@@ -2211,7 +2248,8 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
   int i, j;
 
   Local<FunctionTemplate> process_template = FunctionTemplate::New();
-  process_template->SetClassName(String::New("process"));
+  process_template->SetClassName(
+      FIXED_ONE_BYTE_STRING(node_isolate, "process"));
 
   Local<Object> process = process_template->GetFunction()->NewInstance();
   assert(process.IsEmpty() == false);
@@ -2219,12 +2257,14 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
 
   process_p.Reset(node_isolate, process);
 
-  process->SetAccessor(String::New("title"),
+  process->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "title"),
                        ProcessTitleGetter,
                        ProcessTitleSetter);
 
   // process.version
-  READONLY_PROPERTY(process, "version", String::New(NODE_VERSION));
+  READONLY_PROPERTY(process,
+                    "version",
+                    FIXED_ONE_BYTE_STRING(node_isolate, NODE_VERSION));
 
   // process.moduleLoadList
   Local<Array> modules = Array::New();
@@ -2234,17 +2274,33 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
   // process.versions
   Local<Object> versions = Object::New();
   READONLY_PROPERTY(process, "versions", versions);
-  READONLY_PROPERTY(versions, "http_parser", String::New(
-                    NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR) "."
-                    NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR)));
+
+  const char http_parser_version[] = NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)
+                                     "."
+                                     NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR);
+  READONLY_PROPERTY(versions,
+                    "http_parser",
+                    FIXED_ONE_BYTE_STRING(node_isolate, http_parser_version));
+
   // +1 to get rid of the leading 'v'
-  READONLY_PROPERTY(versions, "node", String::New(NODE_VERSION+1));
-  READONLY_PROPERTY(versions, "v8", String::New(V8::GetVersion()));
-  READONLY_PROPERTY(versions, "uv", String::New(uv_version_string()));
-  READONLY_PROPERTY(versions, "zlib", String::New(ZLIB_VERSION));
+  READONLY_PROPERTY(versions,
+                    "node",
+                    OneByteString(node_isolate, NODE_VERSION + 1));
+  READONLY_PROPERTY(versions,
+                    "v8",
+                    OneByteString(node_isolate, V8::GetVersion()));
+  READONLY_PROPERTY(versions,
+                    "uv",
+                    OneByteString(node_isolate, uv_version_string()));
+  READONLY_PROPERTY(versions,
+                    "zlib",
+                    FIXED_ONE_BYTE_STRING(node_isolate, ZLIB_VERSION));
+
+  const char node_modules_version[] = NODE_STRINGIFY(NODE_MODULE_VERSION);
   READONLY_PROPERTY(versions,
                     "modules",
-                    String::New(NODE_STRINGIFY(NODE_MODULE_VERSION)));
+                    FIXED_ONE_BYTE_STRING(node_isolate, node_modules_version));
+
 #if HAVE_OPENSSL
   // Stupid code to slice out the version string.
   int c, l = strlen(OPENSSL_VERSION_TEXT);
@@ -2258,37 +2314,36 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
       break;
     }
   }
-  READONLY_PROPERTY(versions,
-                    "openssl",
-                    String::New(&OPENSSL_VERSION_TEXT[i], j - i));
+  READONLY_PROPERTY(
+      versions,
+      "openssl",
+      OneByteString(node_isolate, &OPENSSL_VERSION_TEXT[i], j - i));
 #endif
 
 
 
   // process.arch
-  READONLY_PROPERTY(process, "arch", String::New(ARCH));
+  READONLY_PROPERTY(process, "arch", OneByteString(node_isolate, ARCH));
 
   // process.platform
-  READONLY_PROPERTY(process, "platform", String::New(PLATFORM));
+  READONLY_PROPERTY(process,
+                    "platform",
+                    OneByteString(node_isolate, PLATFORM));
 
   // process.argv
   Local<Array> arguments = Array::New(argc - option_end_index + 1);
-  arguments->Set(Integer::New(0, node_isolate), String::New(argv[0]));
+  arguments->Set(0, String::NewFromUtf8(node_isolate, argv[0]));
   for (j = 1, i = option_end_index; i < argc; j++, i++) {
-    Local<String> arg = String::New(argv[i]);
-    arguments->Set(Integer::New(j, node_isolate), arg);
+    arguments->Set(j, String::NewFromUtf8(node_isolate, argv[i]));
   }
-  // assign it
-  process->Set(String::NewSymbol("argv"), arguments);
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "argv"), arguments);
 
   // process.execArgv
-  Local<Array> execArgv = Array::New(option_end_index - 1);
+  Local<Array> exec_argv = Array::New(option_end_index - 1);
   for (j = 1, i = 0; j < option_end_index; j++, i++) {
-    execArgv->Set(Integer::New(i, node_isolate), String::New(argv[j]));
+    exec_argv->Set(i, String::NewFromUtf8(node_isolate, argv[j]));
   }
-  // assign it
-  process->Set(String::NewSymbol("execArgv"), execArgv);
-
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "execArgv"), exec_argv);
 
   // create process.env
   Local<ObjectTemplate> envTemplate = ObjectTemplate::New();
@@ -2299,17 +2354,20 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
                                        EnvEnumerator,
                                        Object::New());
   Local<Object> env = envTemplate->NewInstance();
-  process->Set(String::NewSymbol("env"), env);
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "env"), env);
 
   READONLY_PROPERTY(process, "pid", Integer::New(getpid(), node_isolate));
   READONLY_PROPERTY(process, "features", GetFeatures());
-  process->SetAccessor(String::New("_needImmediateCallback"),
-                       NeedImmediateCallbackGetter,
-                       NeedImmediateCallbackSetter);
+  process->SetAccessor(
+      FIXED_ONE_BYTE_STRING(node_isolate, "_needImmediateCallback"),
+      NeedImmediateCallbackGetter,
+      NeedImmediateCallbackSetter);
 
   // -e, --eval
   if (eval_string) {
-    READONLY_PROPERTY(process, "_eval", String::New(eval_string));
+    READONLY_PROPERTY(process,
+                      "_eval",
+                      String::NewFromUtf8(node_isolate, eval_string));
   }
 
   // -p, --print
@@ -2337,21 +2395,25 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
     READONLY_PROPERTY(process, "traceDeprecation", True(node_isolate));
   }
 
-  size_t size = 2*PATH_MAX;
-  char* execPath = new char[size];
-  if (uv_exepath(execPath, &size) != 0) {
-    // as a last ditch effort, fallback on argv[0] ?
-    process->Set(String::NewSymbol("execPath"), String::New(argv[0]));
+  size_t exec_path_len = 2 * PATH_MAX;
+  char* exec_path = new char[exec_path_len];
+  Local<String> exec_path_value;
+  if (uv_exepath(exec_path, &exec_path_len) == 0) {
+    exec_path_value = String::NewFromUtf8(node_isolate,
+                                          exec_path,
+                                          String::kNormalString,
+                                          exec_path_len);
   } else {
-    process->Set(String::NewSymbol("execPath"), String::New(execPath, size));
+    exec_path_value = String::NewFromUtf8(node_isolate, argv[0]);
   }
-  delete [] execPath;
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "execPath"),
+               exec_path_value);
+  delete[] exec_path;
 
-  process->SetAccessor(String::New("debugPort"),
+  process->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "debugPort"),
                        DebugPortGetter,
                        DebugPortSetter);
 
-
   // define various internal methods
   NODE_SET_METHOD(process, "_getActiveRequests", GetActiveRequests);
   NODE_SET_METHOD(process, "_getActiveHandles", GetActiveHandles);
@@ -2396,10 +2458,10 @@ Handle<Object> SetupProcessObject(int argc, char *argv[]) {
   info_box->SetIndexedPropertiesToExternalArrayData(&tick_infobox,
                                                     kExternalUnsignedIntArray,
                                                     4);
-  process->Set(String::NewSymbol("_tickInfoBox"), info_box);
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickInfoBox"), info_box);
 
   // pre-set _events object for faster emit checks
-  process->Set(String::NewSymbol("_events"), Object::New());
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_events"), Object::New());
 
   return scope.Close(process);
 }
@@ -2422,8 +2484,8 @@ static void SignalExit(int signal) {
 void Load(Handle<Object> process_l) {
   HandleScope handle_scope(node_isolate);
 
-  process_symbol = String::New("process");
-  domain_symbol = String::New("domain");
+  process_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "process");
+  domain_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "domain");
 
   // Compile, execute the src/node.js file. (Which was included as static C
   // string in node_natives.h. 'natve_node' is the string containing that
@@ -2439,7 +2501,8 @@ void Load(Handle<Object> process_l) {
   // are not safe to ignore.
   try_catch.SetVerbose(false);
 
-  Local<Value> f_value = ExecuteString(MainSource(), String::New("node.js"));
+  Local<String> script_name = FIXED_ONE_BYTE_STRING(node_isolate, "node.js");
+  Local<Value> f_value = ExecuteString(MainSource(), script_name);
   if (try_catch.HasCaught())  {
     ReportException(try_catch);
     exit(10);
@@ -2632,8 +2695,12 @@ static void DispatchMessagesDebugAgentCallback() {
 static void EmitDebugEnabledAsyncCallback(uv_async_t* handle, int status) {
   HandleScope handle_scope(node_isolate);
   Local<Object> obj = Object::New();
-  obj->Set(String::New("cmd"), String::New("NODE_DEBUG_ENABLED"));
-  Local<Value> args[] = { String::New("internalMessage"), obj };
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "cmd"),
+           FIXED_ONE_BYTE_STRING(node_isolate, "NODE_DEBUG_ENABLED"));
+  Local<Value> args[] = {
+    FIXED_ONE_BYTE_STRING(node_isolate, "internalMessage"),
+    obj
+  };
   MakeCallback(process_p, "emit", ARRAY_SIZE(args), args);
 }
 
@@ -3001,8 +3068,12 @@ void AtExit(void (*cb)(void* arg), void* arg) {
 
 void EmitExit(v8::Handle<v8::Object> process_l) {
   // process.emit('exit')
-  process_l->Set(String::NewSymbol("_exiting"), True(node_isolate));
-  Local<Value> args[] = { String::New("exit"), Integer::New(0, node_isolate) };
+  process_l->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_exiting"),
+                 True(node_isolate));
+  Local<Value> args[] = {
+    FIXED_ONE_BYTE_STRING(node_isolate, "exit"),
+    Integer::New(0, node_isolate)
+  };
   MakeCallback(process_l, "emit", ARRAY_SIZE(args), args);
 }
 
diff --git a/src/node.h b/src/node.h
index f41495c..d7996fb 100644
--- a/src/node.h
+++ b/src/node.h
@@ -129,20 +129,30 @@ void EmitExit(v8::Handle<v8::Object> process);
 #define NODE_UNIXTIME_V8(t) v8::Date::New(1000*static_cast<double>(t))
 #define NODE_V8_UNIXTIME(v) (static_cast<double>((v)->NumberValue())/1000.0);
 
-#define NODE_DEFINE_CONSTANT(target, constant)                            \
-  (target)->Set(v8::String::NewSymbol(#constant),                         \
-                v8::Number::New(constant),                                \
-                static_cast<v8::PropertyAttribute>(                       \
-                    v8::ReadOnly|v8::DontDelete))
+// Used to be a macro, hence the uppercase name.
+#define NODE_DEFINE_CONSTANT(target, constant)                                \
+  do {                                                                        \
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();                         \
+    v8::Local<v8::String> constant_name =                                     \
+        v8::String::NewFromUtf8(isolate, #constant);                          \
+    v8::Local<v8::Number> constant_value =                                    \
+        v8::Number::New(isolate, static_cast<double>(constant));              \
+    v8::PropertyAttribute constant_attributes =                               \
+        static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);    \
+    (target)->Set(constant_name, constant_value, constant_attributes);        \
+  }                                                                           \
+  while (0)
 
 // Used to be a macro, hence the uppercase name.
 template <typename TypeName>
 inline void NODE_SET_METHOD(const TypeName& recv,
                             const char* name,
                             v8::FunctionCallback callback) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
   v8::Local<v8::Function> fn = t->GetFunction();
-  v8::Local<v8::String> fn_name = v8::String::New(name);
+  v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name);
   fn->SetName(fn_name);
   recv->Set(fn_name, fn);
 }
@@ -153,8 +163,11 @@ inline void NODE_SET_METHOD(const TypeName& recv,
 inline void NODE_SET_PROTOTYPE_METHOD(v8::Handle<v8::FunctionTemplate> recv,
                                       const char* name,
                                       v8::FunctionCallback callback) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
-  recv->PrototypeTemplate()->Set(v8::String::New(name), t->GetFunction());
+  recv->PrototypeTemplate()->Set(v8::String::NewFromUtf8(isolate, name),
+                                 t->GetFunction());
 }
 #define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD
 
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 480b275..b69ff63 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -559,13 +559,14 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
 
   Local<Function> bv = args[0].As<Function>();
   p_buffer_fn.Reset(node_isolate, bv);
-  Local<Value> proto_v = bv->Get(String::New("prototype"));
+  Local<Value> proto_v =
+      bv->Get(FIXED_ONE_BYTE_STRING(node_isolate, "prototype"));
 
   assert(proto_v->IsObject());
 
   Local<Object> proto = proto_v.As<Object>();
 
-  bv->Set(String::New("byteLength"),
+  bv->Set(FIXED_ONE_BYTE_STRING(node_isolate, "byteLength"),
           FunctionTemplate::New(ByteLength)->GetFunction());
 
   NODE_SET_METHOD(proto, "asciiSlice", AsciiSlice);
@@ -596,14 +597,16 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
   NODE_SET_METHOD(proto, "fill", Fill);
 
   // for backwards compatibility
-  proto->Set(String::New("offset"), Uint32::New(0, node_isolate), v8::ReadOnly);
+  proto->Set(FIXED_ONE_BYTE_STRING(node_isolate, "offset"),
+             Uint32::New(0, node_isolate),
+             v8::ReadOnly);
 }
 
 
 void Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
 
-  target->Set(String::New("setupBufferJS"),
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "setupBufferJS"),
               FunctionTemplate::New(SetupBufferJS)->GetFunction());
 }
 
diff --git a/src/node_counters.cc b/src/node_counters.cc
index 111d282..1350a08 100644
--- a/src/node_counters.cc
+++ b/src/node_counters.cc
@@ -114,7 +114,7 @@ void InitPerfCounters(Handle<Object> target) {
   };
 
   for (int i = 0; i < ARRAY_SIZE(tab); i++) {
-    Local<String> key = String::New(tab[i].name);
+    Local<String> key = OneByteString(node_isolate, tab[i].name);
     Local<Value> val = FunctionTemplate::New(tab[i].func)->GetFunction();
     target->Set(key, val);
   }
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index a4687a9..ff30f88 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -179,7 +179,7 @@ void SecureContext::Initialize(Handle<Object> target) {
   secure_context_constructor.Reset(node_isolate, t);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("SecureContext"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "init", SecureContext::Init);
   NODE_SET_PROTOTYPE_METHOD(t, "setKey", SecureContext::SetKey);
@@ -198,7 +198,8 @@ void SecureContext::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "getTicketKeys", SecureContext::GetTicketKeys);
   NODE_SET_PROTOTYPE_METHOD(t, "setTicketKeys", SecureContext::SetTicketKeys);
 
-  target->Set(String::NewSymbol("SecureContext"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"),
+              t->GetFunction());
 }
 
 
@@ -312,7 +313,7 @@ int SecureContext::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
   };
 
   if (onnewsession_sym.IsEmpty()) {
-    onnewsession_sym = String::New("onnewsession");
+    onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
   }
 
   MakeCallback(p->handle(node_isolate),
@@ -647,11 +648,12 @@ void SecureContext::SetSessionIdContext(
 
   bio = BIO_new(BIO_s_mem());
   if (bio == NULL) {
-    message = String::New("SSL_CTX_set_session_id_context error");
+    message = FIXED_ONE_BYTE_STRING(node_isolate,
+                                    "SSL_CTX_set_session_id_context error");
   } else {
     ERR_print_errors(bio);
     BIO_get_mem_ptr(bio, &mem);
-    message = String::New(mem->data, mem->length);
+    message = OneByteString(node_isolate, mem->data, mem->length);
     BIO_free_all(bio);
   }
 
@@ -800,9 +802,9 @@ void Connection::OnClientHello(void* arg,
   Connection* c = static_cast<Connection*>(arg);
 
   if (onclienthello_sym.IsEmpty())
-    onclienthello_sym = String::New("onclienthello");
+    onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
   if (sessionid_sym.IsEmpty())
-    sessionid_sym = String::New("sessionId");
+    sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
 
   Local<Object> obj = Object::New();
   obj->Set(sessionid_sym,
@@ -858,8 +860,10 @@ int Connection::HandleBIOError(BIO *bio, const char* func, int rv) {
     ERR_error_string_n(rv, ssl_error_buf, sizeof(ssl_error_buf));
 
     HandleScope scope(node_isolate);
-    Local<Value> e = Exception::Error(String::New(ssl_error_buf));
-    handle(node_isolate)->Set(String::New("error"), e);
+    Local<Value> exception =
+        Exception::Error(OneByteString(node_isolate, ssl_error_buf));
+    handle(node_isolate)->Set(
+        FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
 
     DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n",
                 ssl_,
@@ -898,8 +902,10 @@ int Connection::HandleSSLError(const char* func,
     return 0;
 
   } else if (err == SSL_ERROR_ZERO_RETURN) {
-    handle(node_isolate)->Set(String::New("error"),
-                              Exception::Error(String::New("ZERO_RETURN")));
+    Local<Value> exception =
+        Exception::Error(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
+    handle(node_isolate)->Set(
+        FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
     return rv;
 
   } else if ((err == SSL_ERROR_SYSCALL) && (ss == kIgnoreSyscall)) {
@@ -920,8 +926,10 @@ int Connection::HandleSSLError(const char* func,
     if ((bio = BIO_new(BIO_s_mem()))) {
       ERR_print_errors(bio);
       BIO_get_mem_ptr(bio, &mem);
-      Local<Value> e = Exception::Error(String::New(mem->data, mem->length));
-      handle(node_isolate)->Set(String::New("error"), e);
+      Local<Value> exception =
+          Exception::Error(OneByteString(node_isolate, mem->data, mem->length));
+      handle(node_isolate)->Set(
+          FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
       BIO_free_all(bio);
     }
 
@@ -937,8 +945,9 @@ void Connection::ClearError() {
   HandleScope scope(node_isolate);
 
   // We should clear the error in JS-land
-  assert(
-      handle(node_isolate)->Get(String::New("error"))->BooleanValue() == false);
+  Local<String> error_key = FIXED_ONE_BYTE_STRING(node_isolate, "error");
+  Local<Value> error = handle(node_isolate)->Get(error_key);
+  assert(error->BooleanValue() == false);
 #endif  // NDEBUG
 }
 
@@ -949,12 +958,15 @@ void Connection::SetShutdownFlags() {
   int flags = SSL_get_shutdown(ssl_);
 
   if (flags & SSL_SENT_SHUTDOWN) {
-    handle(node_isolate)->Set(String::New("sentShutdown"), True(node_isolate));
+    Local<String> sent_shutdown_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "sentShutdown");
+    handle(node_isolate)->Set(sent_shutdown_key, True(node_isolate));
   }
 
   if (flags & SSL_RECEIVED_SHUTDOWN) {
-    handle(node_isolate)->Set(String::New("receivedShutdown"),
-                              True(node_isolate));
+    Local<String> received_shutdown_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "receivedShutdown");
+    handle(node_isolate)->Set(received_shutdown_key, True(node_isolate));
   }
 }
 
@@ -964,7 +976,7 @@ void Connection::Initialize(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("Connection"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "encIn", Connection::EncIn);
   NODE_SET_PROTOTYPE_METHOD(t, "clearOut", Connection::ClearOut);
@@ -1006,7 +1018,8 @@ void Connection::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "setSNICallback",  Connection::SetSNICallback);
 #endif
 
-  target->Set(String::NewSymbol("Connection"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"),
+              t->GetFunction());
 }
 
 
@@ -1109,10 +1122,11 @@ int Connection::SelectNextProtoCallback_(SSL *s,
       p->selectedNPNProto_.Reset(node_isolate, Null(node_isolate));
       break;
     case OPENSSL_NPN_NEGOTIATED:
-      p->selectedNPNProto_.Reset(
-          node_isolate,
-          String::New(reinterpret_cast<const char*>(*out), *outlen));
-      break;
+      {
+        Local<String> string = OneByteString(node_isolate, *out, *outlen);
+        p->selectedNPNProto_.Reset(node_isolate, string);
+        break;
+      }
     case OPENSSL_NPN_NO_OVERLAP:
       p->selectedNPNProto_.Reset(node_isolate, False(node_isolate));
       break;
@@ -1133,7 +1147,8 @@ int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
   const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 
   if (servername) {
-    p->servername_.Reset(node_isolate, String::New(servername));
+    p->servername_.Reset(node_isolate,
+                         OneByteString(node_isolate, servername));
 
     // Call the SNI callback and use its return value as context
     if (!p->sniObject_.IsEmpty()) {
@@ -1247,7 +1262,8 @@ void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
     HandleScope scope(node_isolate);
     Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
     if (onhandshakestart_sym.IsEmpty()) {
-      onhandshakestart_sym = String::New("onhandshakestart");
+      onhandshakestart_sym =
+          FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
     }
     MakeCallback(c->handle(node_isolate), onhandshakestart_sym, 0, NULL);
   }
@@ -1255,7 +1271,8 @@ void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
     HandleScope scope(node_isolate);
     Connection* c = static_cast<Connection*>(SSL_get_app_data(ssl));
     if (onhandshakedone_sym.IsEmpty()) {
-      onhandshakedone_sym = String::New("onhandshakedone");
+      onhandshakedone_sym =
+          FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
     }
     MakeCallback(c->handle(node_isolate), onhandshakedone_sym, 0, NULL);
   }
@@ -1483,14 +1500,16 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
     if (X509_NAME_print_ex(bio, X509_get_subject_name(peer_cert), 0,
                            X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subject_symbol, String::New(mem->data, mem->length));
+      info->Set(subject_symbol,
+                OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
 
     if (X509_NAME_print_ex(bio, X509_get_issuer_name(peer_cert), 0,
                            X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(issuer_symbol, String::New(mem->data, mem->length));
+      info->Set(issuer_symbol,
+                OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
 
@@ -1506,7 +1525,8 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
       assert(rv == 1);
 
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subjectaltname_symbol, String::New(mem->data, mem->length));
+      info->Set(subjectaltname_symbol,
+                OneByteString(node_isolate, mem->data, mem->length));
 
       (void) BIO_reset(bio);
     }
@@ -1517,12 +1537,14 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
         NULL != (rsa = EVP_PKEY_get1_RSA(pkey))) {
         BN_print(bio, rsa->n);
         BIO_get_mem_ptr(bio, &mem);
-        info->Set(modulus_symbol, String::New(mem->data, mem->length) );
+        info->Set(modulus_symbol,
+                  OneByteString(node_isolate, mem->data, mem->length));
         (void) BIO_reset(bio);
 
         BN_print(bio, rsa->e);
         BIO_get_mem_ptr(bio, &mem);
-        info->Set(exponent_symbol, String::New(mem->data, mem->length) );
+        info->Set(exponent_symbol,
+                  OneByteString(node_isolate, mem->data, mem->length));
         (void) BIO_reset(bio);
     }
 
@@ -1537,12 +1559,14 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
 
     ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_from_symbol, String::New(mem->data, mem->length));
+    info->Set(valid_from_symbol,
+              OneByteString(node_isolate, mem->data, mem->length));
     (void) BIO_reset(bio);
 
     ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_to_symbol, String::New(mem->data, mem->length));
+    info->Set(valid_to_symbol,
+              OneByteString(node_isolate, mem->data, mem->length));
     BIO_free_all(bio);
 
     unsigned int md_size, i;
@@ -1563,7 +1587,7 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
         fingerprint[0] = '\0';
       }
 
-      info->Set(fingerprint_symbol, String::New(fingerprint));
+      info->Set(fingerprint_symbol, OneByteString(node_isolate, fingerprint));
     }
 
     STACK_OF(ASN1_OBJECT) *eku = (STACK_OF(ASN1_OBJECT) *)X509_get_ext_d2i(
@@ -1575,7 +1599,8 @@ void Connection::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
       for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
         memset(buf, 0, sizeof(buf));
         OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
-        ext_key_usage->Set(Integer::New(i, node_isolate), String::New(buf));
+        ext_key_usage->Set(Integer::New(i, node_isolate),
+                           OneByteString(node_isolate, buf));
       }
 
       sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
@@ -1748,8 +1773,10 @@ void Connection::VerifyError(const FunctionCallbackInfo<Value>& args) {
     // We requested a certificate and they did not send us one.
     // Definitely an error.
     // XXX is this the right error message?
-    return args.GetReturnValue().Set(
-        Exception::Error(String::New("UNABLE_TO_GET_ISSUER_CERT")));
+    Local<String> error_message =
+        FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
+    Local<Value> exception = Exception::Error(error_message);
+    return args.GetReturnValue().Set(exception);
   }
   X509_free(peer_cert);
 
@@ -1762,115 +1789,121 @@ void Connection::VerifyError(const FunctionCallbackInfo<Value>& args) {
       break;
 
     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
-      s = String::New("UNABLE_TO_GET_ISSUER_CERT");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
       break;
 
     case X509_V_ERR_UNABLE_TO_GET_CRL:
-      s = String::New("UNABLE_TO_GET_CRL");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_CRL");
       break;
 
     case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
-      s = String::New("UNABLE_TO_DECRYPT_CERT_SIGNATURE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate,
+                                "UNABLE_TO_DECRYPT_CERT_SIGNATURE");
       break;
 
     case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
-      s = String::New("UNABLE_TO_DECRYPT_CRL_SIGNATURE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate,
+                                "UNABLE_TO_DECRYPT_CRL_SIGNATURE");
       break;
 
     case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
-      s = String::New("UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
+      s = FIXED_ONE_BYTE_STRING(node_isolate,
+                                "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY");
       break;
 
     case X509_V_ERR_CERT_SIGNATURE_FAILURE:
-      s = String::New("CERT_SIGNATURE_FAILURE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_SIGNATURE_FAILURE");
       break;
 
     case X509_V_ERR_CRL_SIGNATURE_FAILURE:
-      s = String::New("CRL_SIGNATURE_FAILURE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_SIGNATURE_FAILURE");
       break;
 
     case X509_V_ERR_CERT_NOT_YET_VALID:
-      s = String::New("CERT_NOT_YET_VALID");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_NOT_YET_VALID");
       break;
 
     case X509_V_ERR_CERT_HAS_EXPIRED:
-      s = String::New("CERT_HAS_EXPIRED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_HAS_EXPIRED");
       break;
 
     case X509_V_ERR_CRL_NOT_YET_VALID:
-      s = String::New("CRL_NOT_YET_VALID");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_NOT_YET_VALID");
       break;
 
     case X509_V_ERR_CRL_HAS_EXPIRED:
-      s = String::New("CRL_HAS_EXPIRED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CRL_HAS_EXPIRED");
       break;
 
     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
-      s = String::New("ERROR_IN_CERT_NOT_BEFORE_FIELD");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_BEFORE_FIELD");
       break;
 
     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
-      s = String::New("ERROR_IN_CERT_NOT_AFTER_FIELD");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CERT_NOT_AFTER_FIELD");
       break;
 
     case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
-      s = String::New("ERROR_IN_CRL_LAST_UPDATE_FIELD");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_LAST_UPDATE_FIELD");
       break;
 
     case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
-      s = String::New("ERROR_IN_CRL_NEXT_UPDATE_FIELD");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "ERROR_IN_CRL_NEXT_UPDATE_FIELD");
       break;
 
     case X509_V_ERR_OUT_OF_MEM:
-      s = String::New("OUT_OF_MEM");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "OUT_OF_MEM");
       break;
 
     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
-      s = String::New("DEPTH_ZERO_SELF_SIGNED_CERT");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "DEPTH_ZERO_SELF_SIGNED_CERT");
       break;
 
     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
-      s = String::New("SELF_SIGNED_CERT_IN_CHAIN");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "SELF_SIGNED_CERT_IN_CHAIN");
       break;
 
     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
-      s = String::New("UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
+      s = FIXED_ONE_BYTE_STRING(node_isolate,
+                                "UNABLE_TO_GET_ISSUER_CERT_LOCALLY");
       break;
 
     case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
-      s = String::New("UNABLE_TO_VERIFY_LEAF_SIGNATURE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate,
+                                "UNABLE_TO_VERIFY_LEAF_SIGNATURE");
       break;
 
     case X509_V_ERR_CERT_CHAIN_TOO_LONG:
-      s = String::New("CERT_CHAIN_TOO_LONG");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_CHAIN_TOO_LONG");
       break;
 
     case X509_V_ERR_CERT_REVOKED:
-      s = String::New("CERT_REVOKED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REVOKED");
       break;
 
     case X509_V_ERR_INVALID_CA:
-      s = String::New("INVALID_CA");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_CA");
       break;
 
     case X509_V_ERR_PATH_LENGTH_EXCEEDED:
-      s = String::New("PATH_LENGTH_EXCEEDED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "PATH_LENGTH_EXCEEDED");
       break;
 
     case X509_V_ERR_INVALID_PURPOSE:
-      s = String::New("INVALID_PURPOSE");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "INVALID_PURPOSE");
       break;
 
     case X509_V_ERR_CERT_UNTRUSTED:
-      s = String::New("CERT_UNTRUSTED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_UNTRUSTED");
       break;
 
     case X509_V_ERR_CERT_REJECTED:
-      s = String::New("CERT_REJECTED");
+      s = FIXED_ONE_BYTE_STRING(node_isolate, "CERT_REJECTED");
       break;
 
     default:
-      s = String::New(X509_verify_cert_error_string(x509_verify_error));
+      s = OneByteString(node_isolate,
+                        X509_verify_cert_error_string(x509_verify_error));
       break;
   }
 
@@ -1893,9 +1926,9 @@ void Connection::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
   if (c == NULL) return;
   Local<Object> info = Object::New();
   const char* cipher_name = SSL_CIPHER_get_name(c);
-  info->Set(name_symbol, String::New(cipher_name));
+  info->Set(name_symbol, OneByteString(node_isolate, cipher_name));
   const char* cipher_version = SSL_CIPHER_get_version(c);
-  info->Set(version_symbol, String::New(cipher_version));
+  info->Set(version_symbol, OneByteString(node_isolate, cipher_version));
   args.GetReturnValue().Set(info);
 }
 
@@ -1929,7 +1962,7 @@ void Connection::GetNegotiatedProto(const FunctionCallbackInfo<Value>& args) {
     }
 
     args.GetReturnValue().Set(
-        String::New(reinterpret_cast<const char*>(npn_proto), npn_proto_len));
+        OneByteString(node_isolate, npn_proto, npn_proto_len));
   } else {
     args.GetReturnValue().Set(ss->selectedNPNProto_);
   }
@@ -1974,7 +2007,7 @@ void Connection::SetSNICallback(const FunctionCallbackInfo<Value>& args) {
   }
 
   Local<Object> obj = Object::New();
-  obj->Set(String::New("onselect"), args[0]);
+  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "onselect"), args[0]);
   ss->sniObject_.Reset(node_isolate, obj);
 }
 #endif
@@ -1993,7 +2026,8 @@ void CipherBase::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "final", Final);
   NODE_SET_PROTOTYPE_METHOD(t, "setAutoPadding", SetAutoPadding);
 
-  target->Set(String::NewSymbol("CipherBase"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "CipherBase"),
+              t->GetFunction());
 }
 
 
@@ -2232,7 +2266,7 @@ void Hmac::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "update", HmacUpdate);
   NODE_SET_PROTOTYPE_METHOD(t, "digest", HmacDigest);
 
-  target->Set(String::NewSymbol("Hmac"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hmac"), t->GetFunction());
 }
 
 
@@ -2363,7 +2397,7 @@ void Hash::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "update", HashUpdate);
   NODE_SET_PROTOTYPE_METHOD(t, "digest", HashDigest);
 
-  target->Set(String::NewSymbol("Hash"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Hash"), t->GetFunction());
 }
 
 
@@ -2473,7 +2507,7 @@ void Sign::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "update", SignUpdate);
   NODE_SET_PROTOTYPE_METHOD(t, "sign", SignFinal);
 
-  target->Set(String::NewSymbol("Sign"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Sign"), t->GetFunction());
 }
 
 
@@ -2618,7 +2652,7 @@ void Verify::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "update", VerifyUpdate);
   NODE_SET_PROTOTYPE_METHOD(t, "verify", VerifyFinal);
 
-  target->Set(String::NewSymbol("Verify"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Verify"), t->GetFunction());
 }
 
 
@@ -2826,7 +2860,8 @@ void DiffieHellman::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "setPublicKey", SetPublicKey);
   NODE_SET_PROTOTYPE_METHOD(t, "setPrivateKey", SetPrivateKey);
 
-  target->Set(String::NewSymbol("DiffieHellman"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellman"),
+              t->GetFunction());
 
   Local<FunctionTemplate> t2 = FunctionTemplate::New(DiffieHellmanGroup);
   t2->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2838,7 +2873,8 @@ void DiffieHellman::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t2, "getPublicKey", GetPublicKey);
   NODE_SET_PROTOTYPE_METHOD(t2, "getPrivateKey", GetPrivateKey);
 
-  target->Set(String::NewSymbol("DiffieHellmanGroup"), t2->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "DiffieHellmanGroup"),
+              t2->GetFunction());
 }
 
 
@@ -3201,7 +3237,8 @@ void EIO_PBKDF2After(pbkdf2_req* req, Local<Value> argv[2]) {
     argv[1] = Encode(req->key, req->keylen, BUFFER);
     memset(req->key, 0, req->keylen);
   } else {
-    argv[0] = Exception::Error(String::New("PBKDF2 error"));
+    argv[0] = Exception::Error(
+        FIXED_ONE_BYTE_STRING(node_isolate, "PBKDF2 error"));
     argv[1] = Undefined(node_isolate);
   }
 
@@ -3302,7 +3339,7 @@ void PBKDF2(const FunctionCallbackInfo<Value>& args) {
 
   if (args[4]->IsFunction()) {
     Local<Object> obj = Object::New();
-    obj->Set(String::New("ondone"), args[4]);
+    obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[4]);
     req->obj.Reset(node_isolate, obj);
     uv_queue_work(uv_default_loop(),
                   &req->work_req,
@@ -3373,7 +3410,7 @@ void RandomBytesCheck(RandomBytesRequest* req, Local<Value> argv[2]) {
     if (req->error_ != (unsigned long) -1)
       ERR_error_string_n(req->error_, errmsg, sizeof errmsg);
 
-    argv[0] = Exception::Error(String::New(errmsg));
+    argv[0] = Exception::Error(OneByteString(node_isolate, errmsg));
     argv[1] = Null(node_isolate);
   } else {
     argv[0] = Null(node_isolate);
@@ -3417,7 +3454,7 @@ void RandomBytes(const FunctionCallbackInfo<Value>& args) {
 
   if (args[1]->IsFunction()) {
     Local<Object> obj = Object::New();
-    obj->Set(String::New("ondone"), args[1]);
+    obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[1]);
     req->obj_.Reset(node_isolate, obj);
 
     uv_queue_work(uv_default_loop(),
@@ -3458,7 +3495,7 @@ void GetSSLCiphers(const FunctionCallbackInfo<Value>& args) {
 
   for (int i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) {
     SSL_CIPHER* cipher = sk_SSL_CIPHER_value(ciphers, i);
-    arr->Set(i, String::New(SSL_CIPHER_get_name(cipher)));
+    arr->Set(i, OneByteString(node_isolate, SSL_CIPHER_get_name(cipher)));
   }
 
   SSL_free(ssl);
@@ -3474,7 +3511,7 @@ static void array_push_back(const TypeName* md,
                             const char* to,
                             void* arg) {
   Local<Array>& arr = *static_cast<Local<Array>*>(arg);
-  arr->Set(arr->Length(), String::New(from));
+  arr->Set(arr->Length(), OneByteString(node_isolate, from));
 }
 
 
@@ -3534,17 +3571,17 @@ void InitCrypto(Handle<Object> target) {
   NODE_SET_METHOD(target, "getCiphers", GetCiphers);
   NODE_SET_METHOD(target, "getHashes", GetHashes);
 
-  subject_symbol    = String::New("subject");
-  issuer_symbol     = String::New("issuer");
-  valid_from_symbol = String::New("valid_from");
-  valid_to_symbol   = String::New("valid_to");
-  subjectaltname_symbol = String::New("subjectaltname");
-  modulus_symbol        = String::New("modulus");
-  exponent_symbol       = String::New("exponent");
-  fingerprint_symbol   = String::New("fingerprint");
-  name_symbol       = String::New("name");
-  version_symbol    = String::New("version");
-  ext_key_usage_symbol = String::New("ext_key_usage");
+  subject_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
+  issuer_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
+  valid_from_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
+  valid_to_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
+  subjectaltname_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
+  modulus_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
+  exponent_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
+  fingerprint_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
+  name_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "name");
+  version_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "version");
+  ext_key_usage_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
 }
 
 }  // namespace crypto
diff --git a/src/node_dtrace.cc b/src/node_dtrace.cc
index 9d7048b..de2fcea 100644
--- a/src/node_dtrace.cc
+++ b/src/node_dtrace.cc
@@ -77,7 +77,7 @@ using v8::Value;
     return ThrowError( \
         "expected object for " #obj " to contain string member " #member); \
   } \
-  String::Utf8Value _##member(obj->Get(String::New(#member))); \
+  String::Utf8Value _##member(obj->Get(OneByteString(node_isolate, #member))); \
   if ((*(const char **)valp = *_##member) == NULL) \
     *(const char **)valp = "<unknown>";
 
@@ -86,14 +86,14 @@ using v8::Value;
     return ThrowError( \
       "expected object for " #obj " to contain integer member " #member); \
   } \
-  *valp = obj->Get(String::New(#member))->ToInteger()->Value();
+  *valp = obj->Get(OneByteString(node_isolate, #member))->ToInteger()->Value();
 
 #define SLURP_OBJECT(obj, member, valp) \
   if (!(obj)->IsObject()) { \
     return ThrowError( \
       "expected object for " #obj " to contain object member " #member); \
   } \
-  *valp = Local<Object>::Cast(obj->Get(String::New(#member)));
+  *valp = Local<Object>::Cast(obj->Get(OneByteString(node_isolate, #member)));
 
 #define SLURP_CONNECTION(arg, conn) \
   if (!(arg)->IsObject()) { \
@@ -102,7 +102,7 @@ using v8::Value;
   } \
   node_dtrace_connection_t conn; \
   Local<Object> _##conn = Local<Object>::Cast(arg); \
-  Local<Value> _handle = (_##conn)->Get(String::New("_handle")); \
+  Local<Value> _handle = (_##conn)->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_handle")); \
   if (_handle->IsObject()) { \
     SLURP_INT(_handle.As<Object>(), fd, &conn.fd); \
   } else { \
@@ -221,7 +221,7 @@ void DTRACE_HTTP_SERVER_REQUEST(const FunctionCallbackInfo<Value>& args) {
       "expected object for request to contain string member headers");
   }
 
-  Local<Value> strfwdfor = headers->Get(String::New("x-forwarded-for"));
+  Local<Value> strfwdfor = headers->Get(FIXED_ONE_BYTE_STRING(node_isolate, "x-forwarded-for"));
   String::Utf8Value fwdfor(strfwdfor);
 
   if (!strfwdfor->IsString() || (req.forwardedFor = *fwdfor) == NULL)
@@ -332,7 +332,7 @@ void InitDTrace(Handle<Object> target) {
   };
 
   for (unsigned int i = 0; i < ARRAY_SIZE(tab); i++) {
-    Local<String> key = String::New(tab[i].name);
+    Local<String> key = OneByteString(node_isolate, tab[i].name);
     Local<Value> val = FunctionTemplate::New(tab[i].func)->GetFunction();
     target->Set(key, val);
   }
diff --git a/src/node_file.cc b/src/node_file.cc
index 9aa944b..f09973f 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -169,7 +169,8 @@ static void After(uv_fs_t *req) {
         break;
 
       case UV_FS_READLINK:
-        argv[1] = String::New(static_cast<char*>(req->ptr));
+        argv[1] = String::NewFromUtf8(node_isolate,
+                                      static_cast<const char*>(req->ptr));
         break;
 
       case UV_FS_READ:
@@ -185,7 +186,7 @@ static void After(uv_fs_t *req) {
           Local<Array> names = Array::New(nnames);
 
           for (int i = 0; i < nnames; i++) {
-            Local<String> name = String::New(namebuf);
+            Local<String> name = String::NewFromUtf8(node_isolate, namebuf);
             names->Set(Integer::New(i, node_isolate), name);
 #ifndef NDEBUG
             namebuf += strlen(namebuf);
@@ -206,7 +207,7 @@ static void After(uv_fs_t *req) {
   }
 
   if (oncomplete_sym.IsEmpty()) {
-    oncomplete_sym = String::New("oncomplete");
+    oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
   }
   MakeCallback(req_wrap->object(), oncomplete_sym, argc, argv);
 
@@ -290,19 +291,19 @@ Local<Object> BuildStatsObject(const uv_stat_t* s) {
   HandleScope scope(node_isolate);
 
   if (dev_symbol.IsEmpty()) {
-    dev_symbol = String::New("dev");
-    ino_symbol = String::New("ino");
-    mode_symbol = String::New("mode");
-    nlink_symbol = String::New("nlink");
-    uid_symbol = String::New("uid");
-    gid_symbol = String::New("gid");
-    rdev_symbol = String::New("rdev");
-    size_symbol = String::New("size");
-    blksize_symbol = String::New("blksize");
-    blocks_symbol = String::New("blocks");
-    atime_symbol = String::New("atime");
-    mtime_symbol = String::New("mtime");
-    ctime_symbol = String::New("ctime");
+    dev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "dev");
+    ino_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ino");
+    mode_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mode");
+    nlink_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "nlink");
+    uid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "uid");
+    gid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "gid");
+    rdev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rdev");
+    size_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "size");
+    blksize_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blksize");
+    blocks_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blocks");
+    atime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "atime");
+    mtime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mtime");
+    ctime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ctime");
   }
 
   Local<Function> constructor =
@@ -481,8 +482,9 @@ static void ReadLink(const FunctionCallbackInfo<Value>& args) {
     ASYNC_CALL(readlink, args[1], *path)
   } else {
     SYNC_CALL(readlink, *path, *path)
-    args.GetReturnValue().Set(
-        String::New(static_cast<const char*>(SYNC_REQ.ptr)));
+    const char* link_path = static_cast<const char*>(SYNC_REQ.ptr);
+    Local<String> rc = String::NewFromUtf8(node_isolate, link_path);
+    args.GetReturnValue().Set(rc);
   }
 }
 
@@ -621,7 +623,7 @@ static void ReadDir(const FunctionCallbackInfo<Value>& args) {
     Local<Array> names = Array::New(nnames);
 
     for (int i = 0; i < nnames; i++) {
-      Local<String> name = String::New(namebuf);
+      Local<String> name = String::NewFromUtf8(node_isolate, namebuf);
       names->Set(Integer::New(i, node_isolate), name);
 #ifndef NDEBUG
       namebuf += strlen(namebuf);
@@ -1005,12 +1007,12 @@ void InitFs(Handle<Object> target) {
 
   // Initialize the stats object
   Local<Function> constructor = FunctionTemplate::New()->GetFunction();
-  target->Set(String::NewSymbol("Stats"), constructor);
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Stats"), constructor);
   stats_constructor.Reset(node_isolate, constructor);
 
   File::Initialize(target);
 
-  oncomplete_sym = String::New("oncomplete");
+  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 
   StatWatcher::Initialize(target);
 }
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index 5261f26..72fda5e 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -179,7 +179,7 @@ struct StringPtr {
 
   Local<String> ToString() const {
     if (str_)
-      return String::New(str_, size_);
+      return OneByteString(node_isolate, str_, size_);
     else
       return String::Empty(node_isolate);
   }
@@ -433,10 +433,12 @@ class Parser : public ObjectWrap {
     if (!parser->parser_.upgrade && nparsed != buffer_len) {
       enum http_errno err = HTTP_PARSER_ERRNO(&parser->parser_);
 
-      Local<Value> e = Exception::Error(String::NewSymbol("Parse Error"));
+      Local<Value> e = Exception::Error(
+          FIXED_ONE_BYTE_STRING(node_isolate, "Parse Error"));
       Local<Object> obj = e->ToObject();
-      obj->Set(String::NewSymbol("bytesParsed"), nparsed_obj);
-      obj->Set(String::NewSymbol("code"), String::New(http_errno_name(err)));
+      obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "bytesParsed"), nparsed_obj);
+      obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
+               OneByteString(node_isolate, http_errno_name(err)));
       args.GetReturnValue().Set(e);
     } else {
       args.GetReturnValue().Set(nparsed_obj);
@@ -459,10 +461,13 @@ class Parser : public ObjectWrap {
     if (rv != 0) {
       enum http_errno err = HTTP_PARSER_ERRNO(&parser->parser_);
 
-      Local<Value> e = Exception::Error(String::NewSymbol("Parse Error"));
+      Local<Value> e = Exception::Error(
+          FIXED_ONE_BYTE_STRING(node_isolate, "Parse Error"));
       Local<Object> obj = e->ToObject();
-      obj->Set(String::NewSymbol("bytesParsed"), Integer::New(0, node_isolate));
-      obj->Set(String::NewSymbol("code"), String::New(http_errno_name(err)));
+      obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "bytesParsed"),
+               Integer::New(0, node_isolate));
+      obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
+               OneByteString(node_isolate, http_errno_name(err)));
       args.GetReturnValue().Set(e);
     }
   }
@@ -547,38 +552,45 @@ void InitHttpParser(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New(Parser::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("HTTPParser"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"));
 
-  t->Set(String::NewSymbol("REQUEST"),
+  t->Set(FIXED_ONE_BYTE_STRING(node_isolate, "REQUEST"),
          Integer::New(HTTP_REQUEST, node_isolate));
-  t->Set(String::NewSymbol("RESPONSE"),
+  t->Set(FIXED_ONE_BYTE_STRING(node_isolate, "RESPONSE"),
          Integer::New(HTTP_RESPONSE, node_isolate));
 
   NODE_SET_PROTOTYPE_METHOD(t, "execute", Parser::Execute);
   NODE_SET_PROTOTYPE_METHOD(t, "finish", Parser::Finish);
   NODE_SET_PROTOTYPE_METHOD(t, "reinitialize", Parser::Reinitialize);
 
-  target->Set(String::NewSymbol("HTTPParser"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"),
+              t->GetFunction());
 
-  on_headers_sym          = String::New("onHeaders");
-  on_headers_complete_sym = String::New("onHeadersComplete");
-  on_body_sym             = String::New("onBody");
-  on_message_complete_sym = String::New("onMessageComplete");
+  on_headers_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "onHeaders");
+  on_headers_complete_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "onHeadersComplete");
+  on_body_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "onBody");
+  on_message_complete_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "onMessageComplete");
 
-#define X(num, name, string) name##_sym = String::New(#string);
+#define X(num, name, string)                                                  \
+  name ## _sym = OneByteString(node_isolate, #string);
   HTTP_METHOD_MAP(X)
 #undef X
-  unknown_method_sym = String::New("UNKNOWN_METHOD");
-
-  method_sym = String::New("method");
-  status_code_sym = String::New("statusCode");
-  http_version_sym = String::New("httpVersion");
-  version_major_sym = String::New("versionMajor");
-  version_minor_sym = String::New("versionMinor");
-  should_keep_alive_sym = String::New("shouldKeepAlive");
-  upgrade_sym = String::New("upgrade");
-  headers_sym = String::New("headers");
-  url_sym = String::New("url");
+  unknown_method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "UNKNOWN_METHOD");
+
+  method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "method");
+  status_code_sym = FIXED_ONE_BYTE_STRING(node_isolate, "statusCode");
+  http_version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "httpVersion");
+  version_major_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMajor");
+  version_minor_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMinor");
+  should_keep_alive_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "shouldKeepAlive");
+  upgrade_sym = FIXED_ONE_BYTE_STRING(node_isolate, "upgrade");
+  headers_sym = FIXED_ONE_BYTE_STRING(node_isolate, "headers");
+  url_sym = FIXED_ONE_BYTE_STRING(node_isolate, "url");
 
   settings.on_message_begin    = Parser::on_message_begin;
   settings.on_url              = Parser::on_url;
diff --git a/src/node_internals.h b/src/node_internals.h
index d9db29c..082368e 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -25,8 +25,12 @@
 #include "v8.h"
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 
+#define FIXED_ONE_BYTE_STRING(isolate, string)                                \
+  (node::OneByteString((isolate), (string), sizeof(string) - 1))
+
 struct sockaddr;
 
 namespace node {
@@ -95,6 +99,20 @@ inline v8::Local<v8::Object> NewInstance(
     int argc = 0,
     v8::Handle<v8::Value>* argv = NULL);
 
+// Convenience wrapper around v8::String::NewFromOneByte().
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const char* data,
+                                           int length = -1);
+
+// For the people that compile with -funsigned-char.
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const signed char* data,
+                                           int length = -1);
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const unsigned char* data,
+                                           int length = -1);
+
 // Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
 // Sets address and port properties on the info object and returns it.
 // If |info| is omitted, a new object is returned.
@@ -157,7 +175,7 @@ inline static int snprintf(char* buf, unsigned int len, const char* fmt, ...) {
 #define THROW_ERROR(fun)                                                      \
   do {                                                                        \
     v8::HandleScope scope(node_isolate);                                      \
-    v8::ThrowException(fun(v8::String::New(errmsg)));                         \
+    v8::ThrowException(fun(OneByteString(node_isolate, errmsg)));             \
   }                                                                           \
   while (0)
 
@@ -333,6 +351,33 @@ inline v8::Local<v8::Object> NewInstance(
   return constructor_handle->NewInstance(argc, argv);
 }
 
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const signed char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const unsigned char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
 }  // namespace node
 
 #endif  // SRC_NODE_INTERNALS_H_
diff --git a/src/node_javascript.cc b/src/node_javascript.cc
index b37caa3..deddbe2 100644
--- a/src/node_javascript.cc
+++ b/src/node_javascript.cc
@@ -37,7 +37,7 @@ using v8::Object;
 using v8::String;
 
 Handle<String> MainSource() {
-  return String::New(node_native, sizeof(node_native) - 1);
+  return OneByteString(node_isolate, node_native, sizeof(node_native) - 1);
 }
 
 void DefineJavaScript(Handle<Object> target) {
@@ -45,9 +45,11 @@ void DefineJavaScript(Handle<Object> target) {
 
   for (int i = 0; natives[i].name; i++) {
     if (natives[i].source != node_native) {
-      Local<String> name = String::New(natives[i].name);
-      Handle<String> source = String::New(natives[i].source,
-                                                      natives[i].source_len);
+      Local<String> name = String::NewFromUtf8(node_isolate, natives[i].name);
+      Handle<String> source = String::NewFromUtf8(node_isolate,
+                                                  natives[i].source,
+                                                  String::kNormalString,
+                                                  natives[i].source_len);
       target->Set(name, source);
     }
   }
diff --git a/src/node_os.cc b/src/node_os.cc
index cbce5cc..4e79127 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -59,7 +59,7 @@ using v8::Value;
 static void GetEndianness(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
   const char* rval = IsBigEndian() ? "BE" : "LE";
-  args.GetReturnValue().Set(String::New(rval));
+  args.GetReturnValue().Set(OneByteString(node_isolate, rval));
 }
 
 
@@ -77,7 +77,7 @@ static void GetHostname(const FunctionCallbackInfo<Value>& args) {
   }
   buf[sizeof(buf) - 1] = '\0';
 
-  args.GetReturnValue().Set(String::New(buf));
+  args.GetReturnValue().Set(OneByteString(node_isolate, buf));
 }
 
 
@@ -95,7 +95,7 @@ static void GetOSType(const FunctionCallbackInfo<Value>& args) {
   rval ="Windows_NT";
 #endif  // __POSIX__
 
-  args.GetReturnValue().Set(String::New(rval));
+  args.GetReturnValue().Set(OneByteString(node_isolate, rval));
 }
 
 
@@ -125,7 +125,7 @@ static void GetOSRelease(const FunctionCallbackInfo<Value>& args) {
   rval = release;
 #endif  // __POSIX__
 
-  args.GetReturnValue().Set(String::New(rval));
+  args.GetReturnValue().Set(OneByteString(node_isolate, rval));
 }
 
 
@@ -142,21 +142,23 @@ static void GetCPUInfo(const FunctionCallbackInfo<Value>& args) {
     uv_cpu_info_t* ci = cpu_infos + i;
 
     Local<Object> times_info = Object::New();
-    times_info->Set(String::New("user"),
+    times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "user"),
                     Number::New(node_isolate, ci->cpu_times.user));
-    times_info->Set(String::New("nice"),
+    times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "nice"),
                     Number::New(node_isolate, ci->cpu_times.nice));
-    times_info->Set(String::New("sys"),
+    times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "sys"),
                     Number::New(node_isolate, ci->cpu_times.sys));
-    times_info->Set(String::New("idle"),
+    times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "idle"),
                     Number::New(node_isolate, ci->cpu_times.idle));
-    times_info->Set(String::New("irq"),
+    times_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "irq"),
                     Number::New(node_isolate, ci->cpu_times.irq));
 
     Local<Object> cpu_info = Object::New();
-    cpu_info->Set(String::New("model"), String::New(ci->model));
-    cpu_info->Set(String::New("speed"), Number::New(node_isolate, ci->speed));
-    cpu_info->Set(String::New("times"), times_info);
+    cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "model"),
+                  OneByteString(node_isolate, ci->model));
+    cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "speed"),
+                  Number::New(node_isolate, ci->speed));
+    cpu_info->Set(FIXED_ONE_BYTE_STRING(node_isolate, "times"), times_info);
 
     (*cpus)->Set(i, cpu_info);
   }
@@ -221,7 +223,7 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
   ret = Object::New();
 
   for (i = 0; i < count; i++) {
-    name = String::New(interfaces[i].name);
+    name = OneByteString(node_isolate, interfaces[i].name);
     if (ret->Has(name)) {
       ifarr = Local<Array>::Cast(ret->Get(name));
     } else {
@@ -242,24 +244,27 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
     if (interfaces[i].address.address4.sin_family == AF_INET) {
       uv_ip4_name(&interfaces[i].address.address4, ip, sizeof(ip));
       uv_ip4_name(&interfaces[i].netmask.netmask4, netmask, sizeof(netmask));
-      family = String::New("IPv4");
+      family = FIXED_ONE_BYTE_STRING(node_isolate, "IPv4");
     } else if (interfaces[i].address.address4.sin_family == AF_INET6) {
       uv_ip6_name(&interfaces[i].address.address6, ip, sizeof(ip));
       uv_ip6_name(&interfaces[i].netmask.netmask6, netmask, sizeof(netmask));
-      family = String::New("IPv6");
+      family = FIXED_ONE_BYTE_STRING(node_isolate, "IPv6");
     } else {
       strncpy(ip, "<unknown sa family>", INET6_ADDRSTRLEN);
-      family = String::New("<unknown>");
+      family = FIXED_ONE_BYTE_STRING(node_isolate, "<unknown>");
     }
 
     o = Object::New();
-    o->Set(String::New("address"), String::New(ip));
-    o->Set(String::New("netmask"), String::New(netmask));
-    o->Set(String::New("family"), family);
-    o->Set(String::New("mac"), String::New(mac));
+    o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "address"),
+           OneByteString(node_isolate, ip));
+    o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "netmask"),
+           OneByteString(node_isolate, netmask));
+    o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "family"), family);
+    o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "mac"),
+           FIXED_ONE_BYTE_STRING(node_isolate, mac));
 
     const bool internal = interfaces[i].is_internal;
-    o->Set(String::New("internal"),
+    o->Set(FIXED_ONE_BYTE_STRING(node_isolate, "internal"),
            internal ? True(node_isolate) : False(node_isolate));
 
     ifarr->Set(ifarr->Length(), o);
diff --git a/src/node_script.cc b/src/node_script.cc
index d155c51..2795cef 100644
--- a/src/node_script.cc
+++ b/src/node_script.cc
@@ -118,9 +118,10 @@ void CloneObject(Handle<Object> recv,
       "});                                                            \n";
 
   Local<String> script_source =
-      String::New(raw_script_source, sizeof(raw_script_source) - 1);
-  Local<Script> script =
-      Script::Compile(script_source, String::New("binding:script"));
+      FIXED_ONE_BYTE_STRING(node_isolate, raw_script_source);
+  Local<String> script_name =
+      FIXED_ONE_BYTE_STRING(node_isolate, "binding:script");
+  Local<Script> script = Script::Compile(script_source, script_name);
 
   Local<Function> fun = script->Run().As<Function>();
   assert(fun.IsEmpty() == false);
@@ -137,9 +138,9 @@ void WrappedContext::Initialize(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New(WrappedContext::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("Context"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Context"));
 
-  target->Set(String::NewSymbol("Context"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Context"), t->GetFunction());
   constructor_template.Reset(node_isolate, t);
 }
 
@@ -186,7 +187,7 @@ void WrappedScript::Initialize(Handle<Object> target) {
   // Note: We use 'NodeScript' instead of 'Script' so that we do not
   // conflict with V8's Script class defined in v8/src/messages.js
   // See GH-203 https://github.com/joyent/node/issues/203
-  t->SetClassName(String::NewSymbol("NodeScript"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "NodeScript"));
 
   NODE_SET_PROTOTYPE_METHOD(t,
                             "createContext",
@@ -220,7 +221,8 @@ void WrappedScript::Initialize(Handle<Object> target) {
                   "runInNewContext",
                   WrappedScript::CompileRunInNewContext);
 
-  target->Set(String::NewSymbol("NodeScript"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "NodeScript"),
+              t->GetFunction());
 }
 
 
@@ -328,9 +330,12 @@ void WrappedScript::EvalMachine(const FunctionCallbackInfo<Value>& args) {
 
   const int filename_index = sandbox_index +
                              (context_flag == thisContext? 0 : 1);
-  Local<String> filename = args.Length() > filename_index
-                           ? args[filename_index]->ToString()
-                           : String::New("evalmachine.<anonymous>");
+  Local<String> filename;
+  if (args.Length() > filename_index) {
+    filename = args[filename_index]->ToString();
+  } else {
+    filename = FIXED_ONE_BYTE_STRING(node_isolate, "evalmachine.<anonymous>");
+  }
 
   uint64_t timeout = 0;
   const int timeout_index = filename_index + 1;
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index 96e8c19..fb3cf4f 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -46,12 +46,13 @@ void StatWatcher::Initialize(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New(StatWatcher::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("StatWatcher"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "StatWatcher"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "start", StatWatcher::Start);
   NODE_SET_PROTOTYPE_METHOD(t, "stop", StatWatcher::Stop);
 
-  target->Set(String::NewSymbol("StatWatcher"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "StatWatcher"),
+              t->GetFunction());
 }
 
 
@@ -85,7 +86,7 @@ void StatWatcher::Callback(uv_fs_poll_t* handle,
   argv[1] = BuildStatsObject(prev);
   argv[2] = Integer::New(status, node_isolate);
   if (onchange_sym.IsEmpty()) {
-    onchange_sym = String::New("onchange");
+    onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
   }
   MakeCallback(wrap->handle(node_isolate),
                onchange_sym,
@@ -121,7 +122,7 @@ void StatWatcher::Stop(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
   StatWatcher* wrap = ObjectWrap::Unwrap<StatWatcher>(args.This());
   if (onstop_sym.IsEmpty()) {
-    onstop_sym = String::New("onstop");
+    onstop_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onstop");
   }
   MakeCallback(wrap->handle(node_isolate), onstop_sym, 0, NULL);
   wrap->Stop();
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 3368233..d372075 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -294,7 +294,7 @@ class ZCtx : public ObjectWrap {
     assert(handle->Get(onerror_sym)->IsFunction() && "Invalid error handler");
     HandleScope scope(node_isolate);
     Local<Value> args[2] = {
-      String::New(msg),
+      OneByteString(node_isolate, msg),
       Number::New(ctx->err_)
     };
     MakeCallback(handle, onerror_sym, ARRAY_SIZE(args), args);
@@ -543,11 +543,11 @@ void InitZlib(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(z, "params", ZCtx::Params);
   NODE_SET_PROTOTYPE_METHOD(z, "reset", ZCtx::Reset);
 
-  z->SetClassName(String::NewSymbol("Zlib"));
-  target->Set(String::NewSymbol("Zlib"), z->GetFunction());
+  z->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"));
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"), z->GetFunction());
 
-  callback_sym = String::New("callback");
-  onerror_sym = String::New("onerror");
+  callback_sym = FIXED_ONE_BYTE_STRING(node_isolate, "callback");
+  onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
 
   // valid flush values.
   NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
@@ -587,7 +587,8 @@ void InitZlib(Handle<Object> target) {
   NODE_DEFINE_CONSTANT(target, INFLATERAW);
   NODE_DEFINE_CONSTANT(target, UNZIP);
 
-  target->Set(String::NewSymbol("ZLIB_VERSION"), String::New(ZLIB_VERSION));
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ZLIB_VERSION"),
+              FIXED_ONE_BYTE_STRING(node_isolate, ZLIB_VERSION));
 }
 
 }  // namespace node
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index 53c8da9..1aa90e1 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -78,13 +78,13 @@ void PipeWrap::Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
-  t->SetClassName(String::NewSymbol("Pipe"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"));
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
       static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
-  t->InstanceTemplate()->SetAccessor(String::New("fd"),
+  t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
                                      StreamWrap::GetFD,
                                      NULL,
                                      Handle<Value>(),
@@ -117,7 +117,7 @@ void PipeWrap::Initialize(Handle<Object> target) {
 
   pipeConstructorTmpl.Reset(node_isolate, t);
   pipeConstructor.Reset(node_isolate, t->GetFunction());
-  target->Set(String::NewSymbol("Pipe"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"), t->GetFunction());
 }
 
 
@@ -214,7 +214,7 @@ void PipeWrap::OnConnection(uv_stream_t* handle, int status) {
   // Successful accept. Call the onconnection callback in JavaScript land.
   argv[1] = client_obj;
   if (onconnection_sym.IsEmpty()) {
-    onconnection_sym = String::New("onconnection");
+    onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
   }
   MakeCallback(wrap->object(), onconnection_sym, ARRAY_SIZE(argv), argv);
 }
@@ -249,7 +249,7 @@ void PipeWrap::AfterConnect(uv_connect_t* req, int status) {
   };
 
   if (oncomplete_sym.IsEmpty()) {
-    oncomplete_sym = String::New("oncomplete");
+    oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
   }
   MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
 
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 344ac64..10ccb5f 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -50,7 +50,7 @@ class ProcessWrap : public HandleWrap {
 
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
-    constructor->SetClassName(String::NewSymbol("Process"));
+    constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Process"));
 
     NODE_SET_PROTOTYPE_METHOD(constructor, "close", HandleWrap::Close);
 
@@ -60,7 +60,8 @@ class ProcessWrap : public HandleWrap {
     NODE_SET_PROTOTYPE_METHOD(constructor, "ref", HandleWrap::Ref);
     NODE_SET_PROTOTYPE_METHOD(constructor, "unref", HandleWrap::Unref);
 
-    target->Set(String::NewSymbol("Process"), constructor->GetFunction());
+    target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Process"),
+                constructor->GetFunction());
   }
 
  private:
@@ -82,34 +83,41 @@ class ProcessWrap : public HandleWrap {
 
   static void ParseStdioOptions(Local<Object> js_options,
                                 uv_process_options_t* options) {
-    Local<Array> stdios = js_options
-        ->Get(String::NewSymbol("stdio")).As<Array>();
+    Local<String> stdio_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "stdio");
+    Local<Array> stdios = js_options->Get(stdio_key).As<Array>();
     uint32_t len = stdios->Length();
     options->stdio = new uv_stdio_container_t[len];
     options->stdio_count = len;
 
     for (uint32_t i = 0; i < len; i++) {
       Local<Object> stdio = stdios->Get(i).As<Object>();
-      Local<Value> type = stdio->Get(String::NewSymbol("type"));
+      Local<Value> type =
+          stdio->Get(FIXED_ONE_BYTE_STRING(node_isolate, "type"));
 
-      if (type->Equals(String::NewSymbol("ignore"))) {
+      if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "ignore"))) {
         options->stdio[i].flags = UV_IGNORE;
-      } else if (type->Equals(String::NewSymbol("pipe"))) {
+      } else if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "pipe"))) {
         options->stdio[i].flags = static_cast<uv_stdio_flags>(
             UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE);
-        options->stdio[i].data.stream = reinterpret_cast<uv_stream_t*>(
-            PipeWrap::Unwrap(stdio
-                ->Get(String::NewSymbol("handle")).As<Object>())->UVHandle());
-      } else if (type->Equals(String::NewSymbol("wrap"))) {
-        uv_stream_t* stream = HandleToStream(
-            stdio->Get(String::NewSymbol("handle")).As<Object>());
+        Local<String> handle_key =
+            FIXED_ONE_BYTE_STRING(node_isolate, "handle");
+        Local<Object> handle = stdio->Get(handle_key).As<Object>();
+        options->stdio[i].data.stream =
+            reinterpret_cast<uv_stream_t*>(
+                PipeWrap::Unwrap(handle)->UVHandle());
+      } else if (type->Equals(FIXED_ONE_BYTE_STRING(node_isolate, "wrap"))) {
+        Local<String> handle_key =
+            FIXED_ONE_BYTE_STRING(node_isolate, "handle");
+        Local<Object> handle = stdio->Get(handle_key).As<Object>();
+        uv_stream_t* stream = HandleToStream(handle);
         assert(stream != NULL);
 
         options->stdio[i].flags = UV_INHERIT_STREAM;
         options->stdio[i].data.stream = stream;
       } else {
-        int fd = static_cast<int>(
-            stdio->Get(String::NewSymbol("fd"))->IntegerValue());
+        Local<String> fd_key = FIXED_ONE_BYTE_STRING(node_isolate, "fd");
+        int fd = static_cast<int>(stdio->Get(fd_key)->IntegerValue());
 
         options->stdio[i].flags = UV_INHERIT_FD;
         options->stdio[i].data.fd = fd;
@@ -130,7 +138,8 @@ class ProcessWrap : public HandleWrap {
     options.exit_cb = OnExit;
 
     // options.uid
-    Local<Value> uid_v = js_options->Get(String::NewSymbol("uid"));
+    Local<Value> uid_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "uid"));
     if (uid_v->IsInt32()) {
       int32_t uid = uid_v->Int32Value();
       if (uid & ~((uv_uid_t) ~0)) {
@@ -143,7 +152,8 @@ class ProcessWrap : public HandleWrap {
     }
 
     // options.gid
-    Local<Value> gid_v = js_options->Get(String::NewSymbol("gid"));
+    Local<Value> gid_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "gid"));
     if (gid_v->IsInt32()) {
       int32_t gid = gid_v->Int32Value();
       if (gid & ~((uv_gid_t) ~0)) {
@@ -158,7 +168,8 @@ class ProcessWrap : public HandleWrap {
     // TODO(bnoordhuis) is this possible to do without mallocing ?
 
     // options.file
-    Local<Value> file_v = js_options->Get(String::NewSymbol("file"));
+    Local<Value> file_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "file"));
     String::Utf8Value file(file_v->IsString() ? file_v : Local<Value>());
     if (file.length() > 0) {
       options.file = *file;
@@ -167,7 +178,8 @@ class ProcessWrap : public HandleWrap {
     }
 
     // options.args
-    Local<Value> argv_v = js_options->Get(String::NewSymbol("args"));
+    Local<Value> argv_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "args"));
     if (!argv_v.IsEmpty() && argv_v->IsArray()) {
       Local<Array> js_argv = Local<Array>::Cast(argv_v);
       int argc = js_argv->Length();
@@ -181,14 +193,16 @@ class ProcessWrap : public HandleWrap {
     }
 
     // options.cwd
-    Local<Value> cwd_v = js_options->Get(String::NewSymbol("cwd"));
+    Local<Value> cwd_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "cwd"));
     String::Utf8Value cwd(cwd_v->IsString() ? cwd_v : Local<Value>());
     if (cwd.length() > 0) {
       options.cwd = *cwd;
     }
 
     // options.env
-    Local<Value> env_v = js_options->Get(String::NewSymbol("envPairs"));
+    Local<Value> env_v =
+        js_options->Get(FIXED_ONE_BYTE_STRING(node_isolate, "envPairs"));
     if (!env_v.IsEmpty() && env_v->IsArray()) {
       Local<Array> env = Local<Array>::Cast(env_v);
       int envc = env->Length();
@@ -204,13 +218,16 @@ class ProcessWrap : public HandleWrap {
     ParseStdioOptions(js_options, &options);
 
     // options.windows_verbatim_arguments
-    if (js_options->Get(String::NewSymbol("windowsVerbatimArguments"))->
-          IsTrue()) {
+    Local<String> windows_verbatim_arguments_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "windowsVerbatimArguments");
+    if (js_options->Get(windows_verbatim_arguments_key)->IsTrue()) {
       options.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
     }
 
     // options.detached
-    if (js_options->Get(String::NewSymbol("detached"))->IsTrue()) {
+    Local<String> detached_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "detached");
+    if (js_options->Get(detached_key)->IsTrue()) {
       options.flags |= UV_PROCESS_DETACHED;
     }
 
@@ -218,7 +235,7 @@ class ProcessWrap : public HandleWrap {
 
     if (err == 0) {
       assert(wrap->process_.data == wrap);
-      wrap->object()->Set(String::New("pid"),
+      wrap->object()->Set(FIXED_ONE_BYTE_STRING(node_isolate, "pid"),
                           Integer::New(wrap->process_.pid, node_isolate));
     }
 
@@ -255,11 +272,11 @@ class ProcessWrap : public HandleWrap {
 
     Local<Value> argv[] = {
       Integer::New(exit_status, node_isolate),
-      String::New(signo_string(term_signal))
+      OneByteString(node_isolate, signo_string(term_signal))
     };
 
     if (onexit_sym.IsEmpty()) {
-      onexit_sym = String::New("onexit");
+      onexit_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onexit");
     }
 
     MakeCallback(wrap->object(), onexit_sym, ARRAY_SIZE(argv), argv);
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index 1c1c047..eb617e8 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -46,7 +46,7 @@ class SignalWrap : public HandleWrap {
 
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
-    constructor->SetClassName(String::NewSymbol("Signal"));
+    constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"));
 
     NODE_SET_PROTOTYPE_METHOD(constructor, "close", HandleWrap::Close);
     NODE_SET_PROTOTYPE_METHOD(constructor, "ref", HandleWrap::Ref);
@@ -54,9 +54,10 @@ class SignalWrap : public HandleWrap {
     NODE_SET_PROTOTYPE_METHOD(constructor, "start", Start);
     NODE_SET_PROTOTYPE_METHOD(constructor, "stop", Stop);
 
-    onsignal_sym = String::New("onsignal");
+    onsignal_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onsignal");
 
-    target->Set(String::NewSymbol("Signal"), constructor->GetFunction());
+    target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"),
+                constructor->GetFunction());
   }
 
  private:
diff --git a/src/smalloc.cc b/src/smalloc.cc
index e2ce324..c4c1663 100644
--- a/src/smalloc.cc
+++ b/src/smalloc.cc
@@ -359,7 +359,7 @@ void Alloc(Handle<Object> obj,
   assert(!obj->HasIndexedPropertiesInExternalArrayData());
 
   if (smalloc_sym.IsEmpty()) {
-    smalloc_sym = String::New("_smalloc_p");
+    smalloc_sym = FIXED_ONE_BYTE_STRING(node_isolate, "_smalloc_p");
     using_alloc_cb = true;
   }
 
@@ -466,7 +466,7 @@ void Initialize(Handle<Object> exports) {
   NODE_SET_METHOD(exports, "alloc", Alloc);
   NODE_SET_METHOD(exports, "dispose", AllocDispose);
 
-  exports->Set(String::New("kMaxLength"),
+  exports->Set(FIXED_ONE_BYTE_STRING(node_isolate, "kMaxLength"),
                Uint32::NewFromUnsigned(kMaxLength, node_isolate));
 
   // for performance, begin checking if allocation object may contain
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index 84905ac..538c3db 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -63,11 +63,11 @@ void StreamWrap::Initialize(Handle<Object> target) {
   initialized = true;
 
   HandleScope scope(node_isolate);
-  buffer_sym = String::New("buffer");
-  bytes_sym = String::New("bytes");
-  write_queue_size_sym = String::New("writeQueueSize");
-  onread_sym = String::New("onread");
-  oncomplete_sym = String::New("oncomplete");
+  buffer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "buffer");
+  bytes_sym = FIXED_ONE_BYTE_STRING(node_isolate, "bytes");
+  write_queue_size_sym = FIXED_ONE_BYTE_STRING(node_isolate, "writeQueueSize");
+  onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
+  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 }
 
 
@@ -299,7 +299,7 @@ void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
       // Reference StreamWrap instance to prevent it from being garbage
       // collected before `AfterWrite` is called.
       if (handle_sym.IsEmpty()) {
-        handle_sym = String::New("handle");
+        handle_sym = FIXED_ONE_BYTE_STRING(node_isolate, "handle");
       }
       assert(!req_wrap->persistent().IsEmpty());
       req_wrap->object()->Set(handle_sym, send_handle_obj);
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index 0c15ce6..99a6a9b 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -645,20 +645,14 @@ Local<Value> StringBytes::Encode(const char* buf,
         char* out = new char[buflen];
         force_ascii(buf, out, buflen);
         if (buflen < EXTERN_APEX) {
-          val = String::NewFromOneByte(node_isolate,
-                                       reinterpret_cast<const uint8_t*>(out),
-                                       String::kNormalString,
-                                       buflen);
+          val = OneByteString(node_isolate, out, buflen);
           delete[] out;
         } else {
           val = ExternOneByteString::New(out, buflen);
         }
       } else {
         if (buflen < EXTERN_APEX)
-          val = String::NewFromOneByte(node_isolate,
-                                       reinterpret_cast<const uint8_t*>(buf),
-                                       String::kNormalString,
-                                       buflen);
+          val = OneByteString(node_isolate, buf, buflen);
         else
           val = ExternOneByteString::NewFromCopy(buf, buflen);
       }
@@ -673,10 +667,7 @@ Local<Value> StringBytes::Encode(const char* buf,
 
     case BINARY:
       if (buflen < EXTERN_APEX)
-        val = String::NewFromOneByte(node_isolate,
-                                     reinterpret_cast<const uint8_t*>(buf),
-                                     String::kNormalString,
-                                     buflen);
+        val = OneByteString(node_isolate, buf, buflen);
       else
         val = ExternOneByteString::NewFromCopy(buf, buflen);
       break;
@@ -689,10 +680,7 @@ Local<Value> StringBytes::Encode(const char* buf,
       assert(written == dlen);
 
       if (dlen < EXTERN_APEX) {
-        val = String::NewFromOneByte(node_isolate,
-                                     reinterpret_cast<const uint8_t*>(dst),
-                                     String::kNormalString,
-                                     dlen);
+        val = OneByteString(node_isolate, dst, dlen);
         delete[] dst;
       } else {
         val = ExternOneByteString::New(dst, dlen);
@@ -719,10 +707,7 @@ Local<Value> StringBytes::Encode(const char* buf,
       assert(written == dlen);
 
       if (dlen < EXTERN_APEX) {
-        val = String::NewFromOneByte(node_isolate,
-                                     reinterpret_cast<const uint8_t*>(dst),
-                                     String::kNormalString,
-                                     dlen);
+        val = OneByteString(node_isolate, dst, dlen);
         delete[] dst;
       } else {
         val = ExternOneByteString::New(dst, dlen);
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index 4b9cb31..72e8ec1 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -72,13 +72,13 @@ void TCPWrap::Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
-  t->SetClassName(String::NewSymbol("TCP"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"));
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
       static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
-  t->InstanceTemplate()->SetAccessor(String::New("fd"),
+  t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
                                      StreamWrap::GetFD,
                                      NULL,
                                      Handle<Value>(),
@@ -119,12 +119,12 @@ void TCPWrap::Initialize(Handle<Object> target) {
                             SetSimultaneousAccepts);
 #endif
 
-  onconnection_sym = String::New("onconnection");
-  oncomplete_sym = String::New("oncomplete");
+  onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
+  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 
   tcpConstructorTmpl.Reset(node_isolate, t);
   tcpConstructor.Reset(node_isolate, t->GetFunction());
-  target->Set(String::NewSymbol("TCP"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"), t->GetFunction());
 }
 
 
@@ -431,11 +431,11 @@ Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
   int port;
 
   if (address_sym.IsEmpty()) {
-    address_sym = String::New("address");
-    family_sym = String::New("family");
-    port_sym = String::New("port");
-    ipv4_sym = String::New("IPv4");
-    ipv6_sym = String::New("IPv6");
+    address_sym = FIXED_ONE_BYTE_STRING(node_isolate, "address");
+    family_sym = FIXED_ONE_BYTE_STRING(node_isolate, "family");
+    port_sym = FIXED_ONE_BYTE_STRING(node_isolate, "port");
+    ipv4_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv4");
+    ipv6_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv6");
   }
 
   if (info.IsEmpty()) info = Object::New();
@@ -445,7 +445,7 @@ Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
     a6 = reinterpret_cast<const sockaddr_in6*>(addr);
     uv_inet_ntop(AF_INET6, &a6->sin6_addr, ip, sizeof ip);
     port = ntohs(a6->sin6_port);
-    info->Set(address_sym, String::New(ip));
+    info->Set(address_sym, OneByteString(node_isolate, ip));
     info->Set(family_sym, ipv6_sym);
     info->Set(port_sym, Integer::New(port, node_isolate));
     break;
@@ -454,7 +454,7 @@ Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
     a4 = reinterpret_cast<const sockaddr_in*>(addr);
     uv_inet_ntop(AF_INET, &a4->sin_addr, ip, sizeof ip);
     port = ntohs(a4->sin_port);
-    info->Set(address_sym, String::New(ip));
+    info->Set(address_sym, OneByteString(node_isolate, ip));
     info->Set(family_sym, ipv4_sym);
     info->Set(port_sym, Integer::New(port, node_isolate));
     break;
diff --git a/src/timer_wrap.cc b/src/timer_wrap.cc
index 3ba1f19..1f62db9 100644
--- a/src/timer_wrap.cc
+++ b/src/timer_wrap.cc
@@ -44,7 +44,7 @@ class TimerWrap : public HandleWrap {
 
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
-    constructor->SetClassName(String::NewSymbol("Timer"));
+    constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Timer"));
 
     NODE_SET_METHOD(constructor, "now", Now);
 
@@ -58,9 +58,10 @@ class TimerWrap : public HandleWrap {
     NODE_SET_PROTOTYPE_METHOD(constructor, "getRepeat", GetRepeat);
     NODE_SET_PROTOTYPE_METHOD(constructor, "again", Again);
 
-    ontimeout_sym = String::New("ontimeout");
+    ontimeout_sym = FIXED_ONE_BYTE_STRING(node_isolate, "ontimeout");
 
-    target->Set(String::NewSymbol("Timer"), constructor->GetFunction());
+    target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Timer"),
+                constructor->GetFunction());
   }
 
  private:
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 3cc169e..fd8fcbf 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -420,7 +420,7 @@ void TLSCallbacks::EncOutCb(uv_write_t* req, int status) {
 
     // Notify about error
     Local<Value> arg = String::Concat(
-        String::New("write cb error, status: "),
+        FIXED_ONE_BYTE_STRING(node_isolate, "write cb error, status: "),
         Integer::New(status, node_isolate)->ToString());
     MakeCallback(callbacks->object(), onerror_sym, 1, &arg);
     callbacks->InvokeQueued(status);
@@ -446,7 +446,7 @@ Handle<Value> TLSCallbacks::GetSSLError(int status, int* err) {
     case SSL_ERROR_WANT_WRITE:
       break;
     case SSL_ERROR_ZERO_RETURN:
-      return scope.Close(String::NewSymbol("ZERO_RETURN"));
+      return scope.Close(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
       break;
     default:
       {
@@ -459,10 +459,12 @@ Handle<Value> TLSCallbacks::GetSSLError(int status, int* err) {
         assert(bio != NULL);
         ERR_print_errors(bio);
         BIO_get_mem_ptr(bio, &mem);
-        Handle<Value> r = Exception::Error(String::New(mem->data, mem->length));
+        Local<String> message =
+            OneByteString(node_isolate, mem->data, mem->length);
+        Local<Value> exception = Exception::Error(message);
         BIO_free_all(bio);
 
-        return scope.Close(r);
+        return scope.Close(exception);
       }
   }
   return Handle<Value>();
@@ -672,7 +674,8 @@ void TLSCallbacks::VerifyError(const FunctionCallbackInfo<Value>& args) {
     // We requested a certificate and they did not send us one.
     // Definitely an error.
     // XXX is this the right error message?
-    Local<String> s = String::New("UNABLE_TO_GET_ISSUER_CERT");
+    Local<String> s =
+        FIXED_ONE_BYTE_STRING(node_isolate, "UNABLE_TO_GET_ISSUER_CERT");
     return args.GetReturnValue().Set(Exception::Error(s));
   }
   X509_free(peer_cert);
@@ -712,12 +715,13 @@ void TLSCallbacks::VerifyError(const FunctionCallbackInfo<Value>& args) {
   CASE_X509_ERR(CERT_UNTRUSTED)
   CASE_X509_ERR(CERT_REJECTED)
   default:
-    s = String::New(X509_verify_cert_error_string(x509_verify_error));
+    s = OneByteString(node_isolate,
+                      X509_verify_cert_error_string(x509_verify_error));
     break;
   }
 
   if (s.IsEmpty()) {
-    s = String::New(reason);
+    s = OneByteString(node_isolate, reason);
   }
 
   args.GetReturnValue().Set(Exception::Error(s));
@@ -797,9 +801,9 @@ void TLSCallbacks::OnClientHello(void* arg,
   if (hello.servername() == NULL) {
     hello_obj->Set(servername_sym, String::Empty(node_isolate));
   } else {
-    Local<String> servername = String::New(
-        reinterpret_cast<const char*>(hello.servername()),
-        hello.servername_size());
+    Local<String> servername = OneByteString(node_isolate,
+                                             hello.servername(),
+                                             hello.servername_size());
     hello_obj->Set(servername_sym, servername);
   }
   hello_obj->Set(tls_ticket_sym, Boolean::New(hello.has_ticket()));
@@ -830,7 +834,8 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
                            0,
                            X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subject_sym, String::New(mem->data, mem->length));
+      info->Set(subject_sym,
+                OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
 
@@ -839,7 +844,8 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
                            0,
                            X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(issuer_sym, String::New(mem->data, mem->length));
+      info->Set(issuer_sym,
+                OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
 
@@ -855,7 +861,8 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
       assert(rv == 1);
 
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subjectaltname_sym, String::New(mem->data, mem->length));
+      info->Set(subjectaltname_sym,
+                OneByteString(node_isolate, mem->data, mem->length));
 
       (void) BIO_reset(bio);
     }
@@ -866,12 +873,14 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
         NULL != (rsa = EVP_PKEY_get1_RSA(pkey))) {
       BN_print(bio, rsa->n);
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(modulus_sym, String::New(mem->data, mem->length) );
+      info->Set(modulus_sym,
+                OneByteString(node_isolate, mem->data, mem->length));
       (void) BIO_reset(bio);
 
       BN_print(bio, rsa->e);
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(exponent_sym, String::New(mem->data, mem->length) );
+      info->Set(exponent_sym,
+                OneByteString(node_isolate, mem->data, mem->length));
       (void) BIO_reset(bio);
     }
 
@@ -886,12 +895,14 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
 
     ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_from_sym, String::New(mem->data, mem->length));
+    info->Set(valid_from_sym,
+              OneByteString(node_isolate, mem->data, mem->length));
     (void) BIO_reset(bio);
 
     ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_to_sym, String::New(mem->data, mem->length));
+    info->Set(valid_to_sym,
+              OneByteString(node_isolate, mem->data, mem->length));
     BIO_free_all(bio);
 
     unsigned int md_size, i;
@@ -911,7 +922,7 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
       else
         fingerprint[0] = '\0';
 
-      info->Set(fingerprint_sym, String::New(fingerprint));
+      info->Set(fingerprint_sym, OneByteString(node_isolate, fingerprint));
     }
 
     STACK_OF(ASN1_OBJECT)* eku = static_cast<STACK_OF(ASN1_OBJECT)*>(
@@ -926,7 +937,8 @@ void TLSCallbacks::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
       for (int i = 0; i < sk_ASN1_OBJECT_num(eku); i++) {
         memset(buf, 0, sizeof(buf));
         OBJ_obj2txt(buf, sizeof(buf) - 1, sk_ASN1_OBJECT_value(eku, i), 1);
-        ext_key_usage->Set(Integer::New(i, node_isolate), String::New(buf));
+        ext_key_usage->Set(Integer::New(i, node_isolate),
+                           OneByteString(node_isolate, buf));
       }
 
       sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
@@ -1022,7 +1034,8 @@ void TLSCallbacks::LoadSession(const FunctionCallbackInfo<Value>& args) {
     if (sess->tlsext_hostname == NULL) {
       info->Set(servername_sym, False(node_isolate));
     } else {
-      info->Set(servername_sym, String::New(sess->tlsext_hostname));
+      info->Set(servername_sym,
+                OneByteString(node_isolate, sess->tlsext_hostname));
     }
 #endif
     args.GetReturnValue().Set(info);
@@ -1053,8 +1066,8 @@ void TLSCallbacks::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
   const char* cipher_version = SSL_CIPHER_get_version(c);
 
   Local<Object> info = Object::New();
-  info->Set(name_sym, String::New(cipher_name));
-  info->Set(version_sym, String::New(cipher_version));
+  info->Set(name_sym, OneByteString(node_isolate, cipher_name));
+  info->Set(version_sym, OneByteString(node_isolate, cipher_version));
   args.GetReturnValue().Set(info);
 }
 
@@ -1115,7 +1128,7 @@ int TLSCallbacks::SelectNextProtoCallback(SSL* s,
       result = Null(node_isolate);
       break;
     case OPENSSL_NPN_NEGOTIATED:
-      result = String::New(reinterpret_cast<const char*>(*out), *outlen);
+      result = OneByteString(node_isolate, *out, *outlen);
       break;
     case OPENSSL_NPN_NO_OVERLAP:
       result = False(node_isolate);
@@ -1153,7 +1166,7 @@ void TLSCallbacks::GetNegotiatedProto(const FunctionCallbackInfo<Value>& args) {
   }
 
   args.GetReturnValue().Set(
-      String::New(reinterpret_cast<const char*>(npn_proto), npn_proto_len));
+      OneByteString(node_isolate, npn_proto, npn_proto_len));
 }
 
 
@@ -1179,7 +1192,7 @@ void TLSCallbacks::GetServername(const FunctionCallbackInfo<Value>& args) {
   const char* servername = SSL_get_servername(wrap->ssl_,
                                               TLSEXT_NAMETYPE_host_name);
   if (servername != NULL) {
-    args.GetReturnValue().Set(String::New(servername));
+    args.GetReturnValue().Set(OneByteString(node_isolate, servername));
   } else {
     args.GetReturnValue().Set(false);
   }
@@ -1244,7 +1257,7 @@ void TLSCallbacks::Initialize(Handle<Object> target) {
 
   Local<FunctionTemplate> t = FunctionTemplate::New();
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("TLSWrap"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TLSWrap"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "start", Start);
   NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate", GetPeerCertificate);
@@ -1275,28 +1288,29 @@ void TLSCallbacks::Initialize(Handle<Object> target) {
 
   tlsWrap.Reset(node_isolate, t->GetFunction());
 
-  onread_sym = String::New("onread");
-  onerror_sym = String::New("onerror");
-  onhandshakestart_sym = String::New("onhandshakestart");
-  onhandshakedone_sym = String::New("onhandshakedone");
-  onclienthello_sym = String::New("onclienthello");
-  onnewsession_sym = String::New("onnewsession");
-
-  subject_sym = String::New("subject");
-  issuer_sym = String::New("issuer");
-  valid_from_sym = String::New("valid_from");
-  valid_to_sym = String::New("valid_to");
-  subjectaltname_sym = String::New("subjectaltname");
-  modulus_sym = String::New("modulus");
-  exponent_sym = String::New("exponent");
-  fingerprint_sym = String::New("fingerprint");
-  name_sym = String::New("name");
-  version_sym = String::New("version");
-  ext_key_usage_sym = String::New("ext_key_usage");
-  sessionid_sym = String::New("sessionId");
-  tls_ticket_sym = String::New("tlsTicket");
-  servername_sym = String::New("servername");
-  sni_context_sym = String::New("sni_context");
+  onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
+  onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
+  onhandshakestart_sym =
+      FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
+  onhandshakedone_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
+  onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
+  onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
+
+  subject_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
+  issuer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
+  valid_from_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
+  valid_to_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
+  subjectaltname_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
+  modulus_sym = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
+  exponent_sym = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
+  fingerprint_sym = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
+  name_sym = FIXED_ONE_BYTE_STRING(node_isolate, "name");
+  version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "version");
+  ext_key_usage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
+  sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
+  tls_ticket_sym = FIXED_ONE_BYTE_STRING(node_isolate, "tlsTicket");
+  servername_sym = FIXED_ONE_BYTE_STRING(node_isolate, "servername");
+  sni_context_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sni_context");
 }
 
 }  // namespace node
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index a53cfe8..d4f9429 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -49,13 +49,13 @@ void TTYWrap::Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
-  t->SetClassName(String::NewSymbol("TTY"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"));
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
       static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
-  t->InstanceTemplate()->SetAccessor(String::New("fd"),
+  t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
                                      StreamWrap::GetFD,
                                      NULL,
                                      Handle<Value>(),
@@ -82,7 +82,7 @@ void TTYWrap::Initialize(Handle<Object> target) {
   NODE_SET_METHOD(target, "guessHandleType", GuessHandleType);
 
   ttyConstructorTmpl.Reset(node_isolate, t);
-  target->Set(String::NewSymbol("TTY"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"), t->GetFunction());
 }
 
 
@@ -117,7 +117,7 @@ void TTYWrap::GuessHandleType(const FunctionCallbackInfo<Value>& args) {
     abort();
   }
 
-  args.GetReturnValue().Set(String::New(type));
+  args.GetReturnValue().Set(OneByteString(node_isolate, type));
 }
 
 
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 8b43438..5577f7a 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -68,17 +68,17 @@ UDPWrap::~UDPWrap() {
 void UDPWrap::Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
 
-  buffer_sym = String::New("buffer");
-  oncomplete_sym = String::New("oncomplete");
-  onmessage_sym = String::New("onmessage");
+  buffer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "buffer");
+  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
+  onmessage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onmessage");
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(String::NewSymbol("UDP"));
+  t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "UDP"));
 
   enum PropertyAttribute attributes =
       static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
-  t->InstanceTemplate()->SetAccessor(String::New("fd"),
+  t->InstanceTemplate()->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "fd"),
                                      UDPWrap::GetFD,
                                      NULL,
                                      Handle<Value>(),
@@ -104,7 +104,7 @@ void UDPWrap::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "unref", HandleWrap::Unref);
 
   constructor.Reset(node_isolate, t->GetFunction());
-  target->Set(String::NewSymbol("UDP"), t->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "UDP"), t->GetFunction());
 }
 
 
diff --git a/src/uv.cc b/src/uv.cc
index 83c3907..2da32d4 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -40,16 +40,17 @@ void ErrName(const FunctionCallbackInfo<Value>& args) {
   int err = args[0]->Int32Value();
   if (err >= 0) return ThrowError("err >= 0");
   const char* name = uv_err_name(err);
-  args.GetReturnValue().Set(String::New(name));
+  args.GetReturnValue().Set(OneByteString(node_isolate, name));
 }
 
 
 void Initialize(Handle<Object> target) {
   v8::HandleScope handle_scope(node_isolate);
-  target->Set(String::New("errname"),
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "errname"),
               FunctionTemplate::New(ErrName)->GetFunction());
-#define V(name, _) target->Set(String::New("UV_" # name),                     \
-                               Integer::New(UV_ ## name, node_isolate));
+#define V(name, _)                                                            \
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "UV_" # name),              \
+              Integer::New(UV_ ## name, node_isolate));
   UV_ERRNO_MAP(V)
 #undef V
 }