Remove use of wide characters in stats table identifiers.

webkit/port/bindings/v8/V8XMLHttpRequestCustom.cpp

 // Copyright (c) 2008, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 27 matching lines @@
 #include "V8HTMLDocument.h"
 
 #include "ExceptionCode.h"
 #include "Frame.h"
 #include "XMLHttpRequest.h"
 #include "XMLHttpRequestUpload.h"
 
 namespace WebCore {
 
 CALLBACK_FUNC_DECL(XMLHttpRequestConstructor) {
-  INC_STATS(L"DOM.XMLHttpRequest.Constructor");
+  INC_STATS("DOM.XMLHttpRequest.Constructor");
 
   if (!args.IsConstructCall()) {
     V8Proxy::ThrowError(V8Proxy::TYPE_ERROR,
         "DOM object constructor cannot be called as a function.");
     return v8::Undefined();
   }
   // Expect no parameters.
   // Allocate a XMLHttpRequest object as its internal field.
   Document* doc = V8Proxy::retrieveFrame()->document();
   RefPtr<XMLHttpRequest> xhr = XMLHttpRequest::create(doc);
@@ skipping 38 matching lines @@
       cache_array->Delete(i);
       return;
     }
   }
 
   // We should only get here if we try to remove an event listener that was
   // never added.
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnabort) {
-  INC_STATS(L"DOM.XMLHttpRequest.onabort._get");
+  INC_STATS("DOM.XMLHttpRequest.onabort._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onabort()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onabort());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnabort) {
-  INC_STATS(L"DOM.XMLHttpRequest.onabort._set");
+  INC_STATS("DOM.XMLHttpRequest.onabort._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onabort()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onabort());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnabort(0);
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnabort(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnerror) {
-  INC_STATS(L"DOM.XMLHttpRequest.onerror._get");
+  INC_STATS("DOM.XMLHttpRequest.onerror._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onerror()) {
     RefPtr<V8ObjectEventListener> listener =
         static_cast<V8ObjectEventListener*>(imp->onerror());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnerror) {
-  INC_STATS(L"DOM.XMLHttpRequest.onerror._set");
+  INC_STATS("DOM.XMLHttpRequest.onerror._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onerror()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onerror());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnerror(0);
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnerror(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnload) {
-  INC_STATS(L"DOM.XMLHttpRequest.onload._get");
+  INC_STATS("DOM.XMLHttpRequest.onload._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onload()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onload());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnload)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.onload._set");
+  INC_STATS("DOM.XMLHttpRequest.onload._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onload()) {
       V8ObjectEventListener* listener = static_cast<V8ObjectEventListener*>(imp->onload());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     imp->setOnload(0);
 
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnload(listener.get());
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnloadstart) {
-  INC_STATS(L"DOM.XMLHttpRequest.onloadstart._get");
+  INC_STATS("DOM.XMLHttpRequest.onloadstart._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onloadstart()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onloadstart());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnloadstart) {
-  INC_STATS(L"DOM.XMLHttpRequest.onloadstart._set");
+  INC_STATS("DOM.XMLHttpRequest.onloadstart._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onloadstart()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onloadstart());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnloadstart(0);
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnloadstart(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnprogress) {
-  INC_STATS(L"DOM.XMLHttpRequest.onprogress._get");
+  INC_STATS("DOM.XMLHttpRequest.onprogress._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onprogress()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onprogress());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnprogress) {
-  INC_STATS(L"DOM.XMLHttpRequest.onprogress._set");
+  INC_STATS("DOM.XMLHttpRequest.onprogress._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onprogress()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onprogress());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnprogress(0);
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnprogress(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestOnreadystatechange) {
-  INC_STATS(L"DOM.XMLHttpRequest.onreadystatechange._get");
+  INC_STATS("DOM.XMLHttpRequest.onreadystatechange._get");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (imp->onreadystatechange()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onreadystatechange());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestOnreadystatechange)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.onreadystatechange._set");
+  INC_STATS("DOM.XMLHttpRequest.onreadystatechange._set");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onreadystatechange()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onreadystatechange());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnreadystatechange(0);
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnreadystatechange(listener.get());
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestAddEventListener)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.addEventListener()");
+  INC_STATS("DOM.XMLHttpRequest.addEventListener()");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
   if (!proxy)
     return v8::Undefined();
 
   RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(args[1], false);
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     imp->addEventListener(type, listener, useCapture);
 
     CreateHiddenXHRDependency(args.Holder(), args[1]);
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestRemoveEventListener) {
-  INC_STATS(L"DOM.XMLHttpRequest.removeEventListener()");
+  INC_STATS("DOM.XMLHttpRequest.removeEventListener()");
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(imp->scriptExecutionContext());
   if (!proxy)
     return v8::Undefined();  // probably leaked
 
   RefPtr<EventListener> listener =
     proxy->FindObjectEventListener(args[1], false);
 
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     imp->removeEventListener(type, listener.get(), useCapture);
 
     RemoveHiddenXHRDependency(args.Holder(), args[1]);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestOpen)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.open()");
+  INC_STATS("DOM.XMLHttpRequest.open()");
   // Four cases:
   // open(method, url)
   // open(method, url, async)
   // open(method, url, async, user)
   // open(method, url, async, user, passwd)
 
   if (args.Length() < 2) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
@@ skipping 32 matching lines @@
 }
 
 static bool IsDocumentType(v8::Handle<v8::Value> value)
 {
     // TODO(fqian): add other document types.
     return V8Document::HasInstance(value) || V8HTMLDocument::HasInstance(value);
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestSend)
 {
-    INC_STATS(L"DOM.XMLHttpRequest.send()");
+    INC_STATS("DOM.XMLHttpRequest.send()");
   XMLHttpRequest* xhr = V8Proxy::ToNativeObject<XMLHttpRequest>(
         V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
     ExceptionCode ec = 0;
     if (args.Length() < 1)
         xhr->send(ec);
     else {
         v8::Handle<v8::Value> arg = args[0];
         // TODO(eseidel): upstream handles "File" objects too
         if (IsDocumentType(arg)) {
             v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(arg);
             Document* doc = V8Proxy::DOMWrapperToNode<Document>(obj);
             ASSERT(doc);
             xhr->send(doc, ec);
         } else
             xhr->send(valueToStringWithNullCheck(arg), ec);
     }
 
     if (ec) {
         V8Proxy::SetDOMException(ec);
         return v8::Handle<v8::Value>();
     }
 
     return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestSetRequestHeader) {
-  INC_STATS(L"DOM.XMLHttpRequest.setRequestHeader()");
+  INC_STATS("DOM.XMLHttpRequest.setRequestHeader()");
   if (args.Length() < 2) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
   ExceptionCode ec = 0;
   String header = ToWebCoreString(args[0]);
   String value = ToWebCoreString(args[1]);
   imp->setRequestHeader(header, value, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestGetResponseHeader) {
-  INC_STATS(L"DOM.XMLHttpRequest.getResponseHeader()");
+  INC_STATS("DOM.XMLHttpRequest.getResponseHeader()");
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
   ExceptionCode ec = 0;
   String header = ToWebCoreString(args[0]);
   String result = imp->getResponseHeader(header, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return v8StringOrNull(result);
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestOverrideMimeType)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.overrideMimeType()");
+  INC_STATS("DOM.XMLHttpRequest.overrideMimeType()");
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
   XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
   String value = ToWebCoreString(args[0]);
   imp->overrideMimeType(value);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestDispatchEvent)
 {
-  INC_STATS(L"DOM.XMLHttpRequest.dispatchEvent()");
+  INC_STATS("DOM.XMLHttpRequest.dispatchEvent()");
   return v8::Undefined();
 }
 
 
 // XMLHttpRequestUpload --------------------------------------------------------
 
 ACCESSOR_GETTER(XMLHttpRequestUploadOnabort) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onabort._get");
+  INC_STATS("DOM.XMLHttpRequestUpload.onabort._get");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (imp->onabort()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onabort());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestUploadOnabort) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onabort._set");
+  INC_STATS("DOM.XMLHttpRequestUpload.onabort._set");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (value->IsNull()) {
     if (imp->onabort()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onabort());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnabort(0);
   } else {
     XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
     V8Proxy* proxy =
         V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnabort(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestUploadOnerror) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onerror._get");
+  INC_STATS("DOM.XMLHttpRequestUpload.onerror._get");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (imp->onerror()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onerror());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestUploadOnerror) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onerror._set");
+  INC_STATS("DOM.XMLHttpRequestUpload.onerror._set");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (value->IsNull()) {
     if (imp->onerror()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onerror());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnerror(0);
   } else {
     XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
     V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnerror(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestUploadOnload) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onload._get");
+  INC_STATS("DOM.XMLHttpRequestUpload.onload._get");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (imp->onload()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onload());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestUploadOnload) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onload._set");
+  INC_STATS("DOM.XMLHttpRequestUpload.onload._set");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (value->IsNull()) {
     if (imp->onload()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onload());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnload(0);
   } else {
     XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
     V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnload(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestUploadOnloadstart) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onloadstart._get");
+  INC_STATS("DOM.XMLHttpRequestUpload.onloadstart._get");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (imp->onloadstart()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onloadstart());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestUploadOnloadstart) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onloadstart._set");
+  INC_STATS("DOM.XMLHttpRequestUpload.onloadstart._set");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (value->IsNull()) {
     if (imp->onloadstart()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onloadstart());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnloadstart(0);
   } else {
     XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
     V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnloadstart(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 ACCESSOR_GETTER(XMLHttpRequestUploadOnprogress) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onprogress._get");
+  INC_STATS("DOM.XMLHttpRequestUpload.onprogress._get");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (imp->onprogress()) {
     V8ObjectEventListener* listener =
         static_cast<V8ObjectEventListener*>(imp->onprogress());
     v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
     return v8_listener;
   }
   return v8::Undefined();
 }
 
 ACCESSOR_SETTER(XMLHttpRequestUploadOnprogress) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.onprogress._set");
+  INC_STATS("DOM.XMLHttpRequestUpload.onprogress._set");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, info.Holder());
   if (value->IsNull()) {
     if (imp->onprogress()) {
       V8ObjectEventListener* listener =
           static_cast<V8ObjectEventListener*>(imp->onprogress());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     // Clear the listener
     imp->setOnprogress(0);
   } else {
     XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
     V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
     if (!proxy)
       return;
 
     RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(value, false);
     if (listener) {
       imp->setOnprogress(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestUploadAddEventListener) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.addEventListener()");
+  INC_STATS("DOM.XMLHttpRequestUpload.addEventListener()");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, args.Holder());
 
   XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
   V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
   if (!proxy)
     return v8::Undefined();
 
   RefPtr<EventListener> listener =
       proxy->FindOrCreateObjectEventListener(args[1], false);
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     imp->addEventListener(type, listener, useCapture);
 
     CreateHiddenXHRDependency(args.Holder(), args[1]);
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestUploadRemoveEventListener) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.removeEventListener()");
+  INC_STATS("DOM.XMLHttpRequestUpload.removeEventListener()");
   XMLHttpRequestUpload* imp = V8Proxy::ToNativeObject<XMLHttpRequestUpload>(
       V8ClassIndex::XMLHTTPREQUESTUPLOAD, args.Holder());
 
   XMLHttpRequest* xmlhttprequest = imp->associatedXMLHttpRequest();
   V8Proxy* proxy = V8Proxy::retrieve(xmlhttprequest->scriptExecutionContext());
   if (!proxy)
     return v8::Undefined();  // probably leaked
 
   RefPtr<EventListener> listener =
     proxy->FindObjectEventListener(args[1], false);
 
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     imp->removeEventListener(type, listener.get(), useCapture);
 
     RemoveHiddenXHRDependency(args.Holder(), args[1]);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(XMLHttpRequestUploadDispatchEvent) {
-  INC_STATS(L"DOM.XMLHttpRequestUpload.dispatchEvent()");
+  INC_STATS("DOM.XMLHttpRequestUpload.dispatchEvent()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 }  // namespace WebCore