Remove use of wide characters in stats table identifiers.

webkit/port/bindings/v8/v8_custom.cpp

 /*
  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
  *  Copyright (C) 2004-2006 Apple Computer, Inc.
  *  Copyright (C) 2006 James G. Speth (speth@end.com)
  *  Copyright (C) 2006 Samuel Weinig (sam@webkit.org)
  *  Copyright 2007, 2008 Google Inc. All Rights Reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ skipping 240 matching lines @@
   }
 
   if (Document* doc = frame->document())
     doc->updateRendering();
 
   proxy->setTimerCallback(false);
 }
 
 
 CALLBACK_FUNC_DECL(DOMParserConstructor) {
-  INC_STATS(L"DOM.DOMParser.Contructor");
+  INC_STATS("DOM.DOMParser.Contructor");
   return V8Proxy::ConstructDOMObject<V8ClassIndex::DOMPARSER,
                                      DOMParser>(args);
 }
 
 CALLBACK_FUNC_DECL(MessageChannelConstructor) {
-  INC_STATS(L"DOM.MessageChannel.Constructor");
+  INC_STATS("DOM.MessageChannel.Constructor");
   if (!args.IsConstructCall()) {
     V8Proxy::ThrowError(V8Proxy::TYPE_ERROR,
         "DOM object constructor cannot be called as a function.");
     return v8::Undefined();
   }
 
   // Get the document.
   Frame* frame = V8Proxy::retrieveFrame();
   if (!frame)
     return v8::Undefined();
@@ skipping 25 matching lines @@
   wrapper_object->SetInternalField(kMessageChannelPort1Index, port1_wrapper);
   wrapper_object->SetInternalField(kMessageChannelPort2Index, port2_wrapper);
 
   // Return the wrapper object which will be the result of the call to
   // new.
   return wrapper_object;
 }
 
 
 CALLBACK_FUNC_DECL(XMLSerializerConstructor) {
-  INC_STATS(L"DOM.XMLSerializer.Constructor");
+  INC_STATS("DOM.XMLSerializer.Constructor");
   return V8Proxy::ConstructDOMObject<V8ClassIndex::XMLSERIALIZER,
                                      XMLSerializer>(args);
 }
 
 
 CALLBACK_FUNC_DECL(XPathEvaluatorConstructor) {
-  INC_STATS(L"DOM.XPathEvaluator.Constructor");
+  INC_STATS("DOM.XPathEvaluator.Constructor");
   return V8Proxy::ConstructDOMObject<V8ClassIndex::XPATHEVALUATOR,
                                      XPathEvaluator>(args);
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorConstructor) {
-  INC_STATS(L"DOM.XSLTProcessor.Constructor");
+  INC_STATS("DOM.XSLTProcessor.Constructor");
   return V8Proxy::ConstructDOMObject<V8ClassIndex::XSLTPROCESSOR,
                                      XSLTProcessor>(args);
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorImportStylesheet) {
-  INC_STATS(L"DOM.XSLTProcessor.importStylesheet");
+  INC_STATS("DOM.XSLTProcessor.importStylesheet");
   // Return undefined if argument does not have the correct type.
   if (!V8Node::HasInstance(args[0]))
     return v8::Undefined();
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   Node* node = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   imp->importStylesheet(node);
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorTransformToFragment) {
-  INC_STATS(L"DOM.XSLTProcessor.transformToFragment");
+  INC_STATS("DOM.XSLTProcessor.transformToFragment");
   // Return undefined if arguments do not have correct types.
   if (!V8Node::HasInstance(args[0]) || !V8Document::HasInstance(args[1]))
     return v8::Undefined();
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   Node* source = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   Document* owner =
       V8Proxy::DOMWrapperToNode<Document>(args[1]);
   RefPtr<DocumentFragment> result = imp->transformToFragment(source, owner);
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorTransformToDocument) {
-  INC_STATS(L"DOM.XSLTProcessor.transformToDocument");
+  INC_STATS("DOM.XSLTProcessor.transformToDocument");
   // Return undefined if argument does not have the correct type.
   if (!V8Node::HasInstance(args[0]))
     return v8::Undefined();
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   Node* source = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   if (!source)
       return v8::Undefined();
   RefPtr<Document> result = imp->transformToDocument(source);
   // Return undefined if no result was found.
   if (!result)
       return v8::Undefined();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorSetParameter) {
-  INC_STATS(L"DOM.XSLTProcessor.setParameter");
+  INC_STATS("DOM.XSLTProcessor.setParameter");
   // Bail out if localName or value is null or undefined.
   if (args[1]->IsNull() || args[1]->IsUndefined() ||
       args[2]->IsNull() || args[2]->IsUndefined()) {
     return v8::Undefined();
   }
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   String namespaceURI = ToWebCoreString(args[0]);
   String localName = ToWebCoreString(args[1]);
   String value = ToWebCoreString(args[2]);
   imp->setParameter(namespaceURI, localName, value);
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorGetParameter) {
-  INC_STATS(L"DOM.XSLTProcessor.getParameter");
+  INC_STATS("DOM.XSLTProcessor.getParameter");
   // Bail out if localName is null or undefined.
   if (args[1]->IsNull() || args[1]->IsUndefined()) {
     return v8::Undefined();
   }
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   String namespaceURI = ToWebCoreString(args[0]);
   String localName = ToWebCoreString(args[1]);
   String result = imp->getParameter(namespaceURI, localName);
   // Return undefined if the string is null.
   if (result.isNull()) return v8::Undefined();
   return v8String(result);
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorRemoveParameter) {
-  INC_STATS(L"DOM.XSLTProcessor.removeParameter");
+  INC_STATS("DOM.XSLTProcessor.removeParameter");
   // Bail out if localName is null or undefined.
   if (args[1]->IsNull() || args[1]->IsUndefined())
     return v8::Undefined();
 
   XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   String namespaceURI = ToWebCoreString(args[0]);
   String localName = ToWebCoreString(args[1]);
   imp->removeParameter(namespaceURI, localName);
@@ skipping 223 matching lines @@
     else
       return result;
   }
   unsigned i = index->Uint32Value();
   RefPtr<Node> result = collection->item(i);
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLCollection) {
-  INC_STATS(L"DOM.HTMLCollection.NamedPropertyGetter");
+  INC_STATS("DOM.HTMLCollection.NamedPropertyGetter");
   // Search the prototype chain first.
   v8::Handle<v8::Value> value =
       info.Holder()->GetRealNamedPropertyInPrototypeChain(name);
 
   if (!value.IsEmpty()) {
     return value;
   }
 
   // Search local callback properties next to find IDL defined
   // properties.
   if (info.Holder()->HasRealNamedCallbackProperty(name)) {
     return v8::Handle<v8::Value>();
   }
 
   // Finally, search the DOM structure.
   HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, info.Holder());
   String key = ToWebCoreString(name);
   return HTMLCollectionGetNamedItems(imp, key);
 }
 
 INDEXED_PROPERTY_GETTER(CanvasPixelArray) {
-  INC_STATS(L"DOM.CanvasPixelArray.IndexedPropertyGetter");
+  INC_STATS("DOM.CanvasPixelArray.IndexedPropertyGetter");
   CanvasPixelArray* pixelArray =
       V8Proxy::ToNativeObject<CanvasPixelArray>(V8ClassIndex::CANVASPIXELARRAY,
           info.Holder());
 
   // TODO(eroman): This performance will not be good when looping through
   // many pixels. See: http://code.google.com/p/chromium/issues/detail?id=3473
   
   unsigned char result;
   if (!pixelArray->get(index, result))
       return v8::Undefined();
   return v8::Number::New(result);
 }
 
 INDEXED_PROPERTY_SETTER(CanvasPixelArray) {
-  INC_STATS(L"DOM.CanvasPixelArray.IndexedPropertySetter");
+  INC_STATS("DOM.CanvasPixelArray.IndexedPropertySetter");
   CanvasPixelArray* pixelArray =
       V8Proxy::ToNativeObject<CanvasPixelArray>(V8ClassIndex::CANVASPIXELARRAY,
           info.Holder());
 
   double pixelValue = value->NumberValue();
   pixelArray->set(index, pixelValue);
 
   // TODO(eroman): what to return?
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(HTMLCollectionItem) {
-  INC_STATS(L"DOM.HTMLCollection.item()");
+  INC_STATS("DOM.HTMLCollection.item()");
   HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, args.Holder());
   return HTMLCollectionGetItem(imp, args[0]);
 }
 
 
 CALLBACK_FUNC_DECL(HTMLCollectionNamedItem) {
-  INC_STATS(L"DOM.HTMLCollection.namedItem()");
+  INC_STATS("DOM.HTMLCollection.namedItem()");
   HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, args.Holder());
   String name = ToWebCoreString(args[0]);
   v8::Handle<v8::Value> result =
     HTMLCollectionGetNamedItems(imp, name);
   if (result.IsEmpty())
     return v8::Undefined();
   else
     return result;
 }
 
 
 CALLBACK_FUNC_DECL(HTMLCollectionCallAsFunction) {
-  INC_STATS(L"DOM.HTMLCollection.callAsFunction()");
+  INC_STATS("DOM.HTMLCollection.callAsFunction()");
   if (args.Length() < 1) return v8::Undefined();
 
   HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, args.Holder());
 
   if (args.Length() == 1) {
     return HTMLCollectionGetItem(imp, args[0]);
   }
 
   // If there is a second argument it is the index of the item we
@@ skipping 20 matching lines @@
         V8Proxy::DOMWrapperToNode<HTMLOptionElement>(args[0]);
     imp->remove(element->index());
     return v8::Undefined();
   }
 
   imp->remove(ToInt32(args[0]));
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(HTMLSelectElementRemove) {
-  INC_STATS(L"DOM.HTMLSelectElement.remove");
+  INC_STATS("DOM.HTMLSelectElement.remove");
   HTMLSelectElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLSelectElement>(args.Holder());
   return V8HTMLSelectElementRemoveHelper(imp, args);
 }
 
 CALLBACK_FUNC_DECL(HTMLOptionsCollectionRemove) {
-  INC_STATS(L"DOM.HTMLOptionsCollection.remove()");
+  INC_STATS("DOM.HTMLOptionsCollection.remove()");
   HTMLOptionsCollection* imp =
       V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, args.Holder());
   HTMLSelectElement* base = static_cast<HTMLSelectElement*>(imp->base());
   return V8HTMLSelectElementRemoveHelper(base, args);
 }
 
 
 CALLBACK_FUNC_DECL(HTMLOptionsCollectionAdd) {
-  INC_STATS(L"DOM.HTMLOptionsCollection.add()");
+  INC_STATS("DOM.HTMLOptionsCollection.add()");
   if (!V8HTMLOptionElement::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Undefined();
   }
   HTMLOptionsCollection* imp =
       V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, args.Holder());
   HTMLOptionElement* option =
       V8Proxy::DOMWrapperToNode<HTMLOptionElement>(args[0]);
 
@@ skipping 14 matching lines @@
     }
   }
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowAddEventListener) {
-  INC_STATS(L"DOM.DOMWindow.addEventListener()");
+  INC_STATS("DOM.DOMWindow.addEventListener()");
   DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   if (!V8Proxy::CanAccessFrame(imp->frame(), true))
     return v8::Undefined();
 
   if (!imp->frame())
     return v8::Undefined();  // DOMWindow could be disconnected from the frame
 
   Document* doc = imp->frame()->document();
@@ skipping 12 matching lines @@
     String event_type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     doc->addWindowEventListener(event_type, listener, useCapture);
   }
 
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowRemoveEventListener) {
-  INC_STATS(L"DOM.DOMWindow.removeEventListener()");
+  INC_STATS("DOM.DOMWindow.removeEventListener()");
   DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   if (!V8Proxy::CanAccessFrame(imp->frame(), true))
     return v8::Undefined();
 
   if (!imp->frame())
     return v8::Undefined();
 
   Document* doc = imp->frame()->document();
@@ skipping 10 matching lines @@
   if (listener) {
     String event_type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     doc->removeWindowEventListener(event_type, listener.get(), useCapture);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(DOMWindowPostMessage) {
-  INC_STATS(L"DOM.DOMWindow.postMessage()");
+  INC_STATS("DOM.DOMWindow.postMessage()");
   DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   DOMWindow* source = V8Proxy::retrieveActiveFrame()->domWindow();
   ASSERT(source->frame());
 
   String uri = source->frame()->loader()->url().string();
 
   v8::TryCatch try_catch;
 
@@ skipping 135 matching lines @@
           false,
           user_gesture);
     }
   }
 
   return new_frame;
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowShowModalDialog) {
-  INC_STATS(L"DOM.DOMWindow.showModalDialog()");
+  INC_STATS("DOM.DOMWindow.showModalDialog()");
   DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
   Frame* frame = window->frame();
 
   if (!frame || !V8Proxy::CanAccessFrame(frame, true)) 
     return v8::Undefined();
 
   if (!canShowModalDialogNow(frame) || !allowPopUp())
     return v8::Undefined();
 
@@ skipping 69 matching lines @@
 
   if (!return_value.IsEmpty()) {
     return return_value;
   }
 
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowOpen) {
-  INC_STATS(L"DOM.DOMWindow.open()");
+  INC_STATS("DOM.DOMWindow.open()");
   DOMWindow* parent = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
   Frame* frame = parent->frame();
 
   if (!V8Proxy::CanAccessFrame(frame, true))
     return v8::Undefined();
 
   Frame* active_frame = V8Proxy::retrieveActiveFrame();
   if (!active_frame)
     return v8::Undefined();
@@ skipping 107 matching lines @@
   frame = createWindow(frame, url_string, frame_name,
                        window_features, v8::Local<v8::Value>());
 
   if (!frame) return v8::Undefined();
 
   return V8Proxy::ToV8Object(V8ClassIndex::DOMWINDOW, frame->domWindow());
 }
 
 
 INDEXED_PROPERTY_GETTER(DOMWindow) {
-  INC_STATS(L"DOM.DOMWindow.IndexedPropertyGetter");
+  INC_STATS("DOM.DOMWindow.IndexedPropertyGetter");
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return v8::Handle<v8::Value>();
 
   DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, holder);
   if (!window)
     return v8::Handle<v8::Value>();
 
   Frame* frame = window->frame();
   if (!frame)
     return v8::Handle<v8::Value>();
 
   Frame* child = frame->tree()->child(index);
   if (child) {
     return V8Proxy::ToV8Object(V8ClassIndex::DOMWINDOW, child->domWindow());
   }
 
   return v8::Handle<v8::Value>();
 }
 
 
 NAMED_PROPERTY_GETTER(DOMWindow) {
-  INC_STATS(L"DOM.DOMWindow.NamedPropertyGetter");
+  INC_STATS("DOM.DOMWindow.NamedPropertyGetter");
   // The key must be a string.
   if (!name->IsString())
     return v8::Handle<v8::Value>();
 
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return v8::Handle<v8::Value>();
 
   DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
@@ skipping 109 matching lines @@
         info.Holder()->GetInternalField(kHTMLDocumentMarkerIndex);
     info.Holder()->SetInternalField(kHTMLDocumentShadowIndex, marker);
     return v8::True();
   }
   return v8::Handle<v8::Boolean>();
 }
 
 
 NAMED_PROPERTY_SETTER(HTMLDocument)
 {
-  INC_STATS(L"DOM.HTMLDocument.NamedPropertySetter");
+  INC_STATS("DOM.HTMLDocument.NamedPropertySetter");
   // Only handle document.all.  We insert the value into the shadow
   // internal field from which the getter will retrieve it.
   String key = ToWebCoreString(name);
   if (key == "all") {
     ASSERT(info.Holder()->InternalFieldCount() ==
            kHTMLDocumentInternalFieldCount);
     info.Holder()->SetInternalField(kHTMLDocumentShadowIndex, value);
   }
   return v8::Handle<v8::Value>();
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLDocument)
 {
-    INC_STATS(L"DOM.HTMLDocument.NamedPropertyGetter");
+    INC_STATS("DOM.HTMLDocument.NamedPropertyGetter");
     AtomicString key = ToWebCoreString(name);
 
     // Special case for document.all.  If the value in the shadow
     // internal field is not the marker object, then document.all has
     // been temporarily shadowed and we return the value.
     if (key == "all") {
         ASSERT(info.Holder()->InternalFieldCount() == kHTMLDocumentInternalFieldCount);
         v8::Local<v8::Value> marker = info.Holder()->GetInternalField(kHTMLDocumentMarkerIndex);
         v8::Local<v8::Value> value = info.Holder()->GetInternalField(kHTMLDocumentShadowIndex);
         if (marker != value)
@@ skipping 16 matching lines @@
             return V8Proxy::ToV8Object(V8ClassIndex::DOMWINDOW, frame->domWindow());
     return V8Proxy::NodeToV8Object(node);
     }
     return V8Proxy::ToV8Object(V8ClassIndex::HTMLCOLLECTION,
                              static_cast<Peerable*>(items.get()));
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLFrameSetElement)
 {
-  INC_STATS(L"DOM.HTMLFrameSetElement.NamedPropertyGetter");
+  INC_STATS("DOM.HTMLFrameSetElement.NamedPropertyGetter");
   HTMLFrameSetElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLFrameSetElement>(info.Holder());
   String key = ToWebCoreString(name);
   Node* frame = imp->children()->namedItem(key);
   if (frame && frame->hasTagName(HTMLNames::frameTag)) {
     Document* doc = static_cast<HTMLFrameElement*>(frame)->contentDocument();
     if (doc) {
       Frame* content_frame = doc->frame();
       if (content_frame)
         return V8Proxy::ToV8Object(V8ClassIndex::DOMWINDOW, content_frame->domWindow());
     }
     return v8::Undefined();
   }
   return v8::Handle<v8::Value>();
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLFormElement) {
-  INC_STATS(L"DOM.HTMLFormElement.NamedPropertyGetter");
+  INC_STATS("DOM.HTMLFormElement.NamedPropertyGetter");
   HTMLFormElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLFormElement>(info.Holder());
   String v = ToWebCoreString(name);
 
   // Call getNamedElements twice, first time check if it has a value
   // and let HTMLFormElement update its cache.
   // See issue: 867404
   {
     Vector<RefPtr<Node> > elements;
     imp->getNamedElements(v, elements);
     if (elements.size() == 0)
       return v8::Handle<v8::Value>();
   }
   // Second call may return different results from the first call,
   // but if the first the size cannot be zero.
   Vector<RefPtr<Node> > elements;
   imp->getNamedElements(v, elements);
   ASSERT(elements.size() != 0);
   if (elements.size() == 1) {
     return V8Proxy::NodeToV8Object(elements.at(0).get());
   } else {
     NodeList* collection = new V8VectorNodeList(elements);
     return V8Proxy::ToV8Object(V8ClassIndex::NODELIST,
                                static_cast<Peerable*>(collection));
   }
 }
 
 
 INDEXED_PROPERTY_GETTER(NamedNodeMap) {
-  INC_STATS(L"DOM.NamedNodeMap.IndexedPropertyGetter");
+  INC_STATS("DOM.NamedNodeMap.IndexedPropertyGetter");
   NamedNodeMap* imp = V8Proxy::ToNativeObject<NamedNodeMap>(
       V8ClassIndex::NAMEDNODEMAP, info.Holder());
   RefPtr<Node> result = imp->item(index);
   if (!result) return v8::Handle<v8::Value>();
 
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 NAMED_PROPERTY_GETTER(NamedNodeMap) {
-  INC_STATS(L"DOM.NamedNodeMap.NamedPropertyGetter");
+  INC_STATS("DOM.NamedNodeMap.NamedPropertyGetter");
   // Search the prototype chain first.
   v8::Handle<v8::Value> value =
       info.Holder()->GetRealNamedPropertyInPrototypeChain(name);
   if (!value.IsEmpty())
     return value;
 
   // Then look for IDL defined properties on the object itself.
   if (info.Holder()->HasRealNamedCallbackProperty(name))
     return v8::Handle<v8::Value>();
 
   // Finally, search the DOM.
   NamedNodeMap* imp = V8Proxy::ToNativeObject<NamedNodeMap>(
       V8ClassIndex::NAMEDNODEMAP, info.Holder());
   String prop_name = ToWebCoreString(name);
   RefPtr<Node> result = imp->getNamedItem(prop_name);
   if (!result) return v8::Handle<v8::Value>();
 
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 NAMED_PROPERTY_GETTER(NodeList) {
-  INC_STATS(L"DOM.NodeList.NamedPropertyGetter");
+  INC_STATS("DOM.NodeList.NamedPropertyGetter");
   NodeList* list = V8Proxy::ToNativeObject<NodeList>(
       V8ClassIndex::NODELIST, info.Holder());
   String prop_name = ToWebCoreString(name);
 
   // Length property cannot be overridden.
   if (prop_name == "length")
     return v8::Number::New(list->length());
 
   RefPtr<Node> result = list->itemWithName(prop_name);
   if (result)
     return V8Proxy::NodeToV8Object(result.get());
 
   return v8::Handle<v8::Value>();
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLFormElement) {
-  INC_STATS(L"DOM.HTMLFormElement.IndexedPropertyGetter");
+  INC_STATS("DOM.HTMLFormElement.IndexedPropertyGetter");
   HTMLFormElement* form =
       V8Proxy::DOMWrapperToNode<HTMLFormElement>(info.Holder());
 
   RefPtr<Node> result = form->elements()->item(index);
   if (!result) return v8::Handle<v8::Value>();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLOptionsCollection) {
-  INC_STATS(L"DOM.HTMLOptionsCollection.IndexedPropertyGetter");
+  INC_STATS("DOM.HTMLOptionsCollection.IndexedPropertyGetter");
   HTMLOptionsCollection* collection =
       V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, info.Holder());
 
   RefPtr<Node> result = collection->item(index);
   if (!result) return v8::Handle<v8::Value>();
 
   return V8Proxy::NodeToV8Object(result.get());
 }
 
@@ skipping 17 matching lines @@
       V8Proxy::DOMWrapperToNode<HTMLOptionElement>(
           v8::Handle<v8::Object>::Cast(value));
   base->setOption(index, element, ec);
 
   V8Proxy::SetDOMException(ec);
   return value;
 }
 
 
 INDEXED_PROPERTY_SETTER(HTMLOptionsCollection) {
-  INC_STATS(L"DOM.HTMLOptionsCollection.IndexedPropertySetter");
+  INC_STATS("DOM.HTMLOptionsCollection.IndexedPropertySetter");
   HTMLOptionsCollection* collection =
       V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, info.Holder());
   HTMLSelectElement* base = static_cast<HTMLSelectElement*>(collection->base());
   return OptionsCollectionSetter(index, value, base);
 }
 
 
 INDEXED_PROPERTY_SETTER(HTMLSelectElementCollection) {
-  INC_STATS(L"DOM.HTMLSelectElementCollection.IndexedPropertySetter");
+  INC_STATS("DOM.HTMLSelectElementCollection.IndexedPropertySetter");
   HTMLSelectElement* select =
       V8Proxy::DOMWrapperToNode<HTMLSelectElement>(info.Holder());
   return OptionsCollectionSetter(index, value, select);
 }
 
 // Check for a CSS prefix.
 // Passed prefix is all lowercase.
 // First character of the prefix within the property name may be upper or lowercase.
 // Other characters in the prefix within the property name must be lowercase.
 // The prefix within the property name must be followed by a capital letter.
@@ skipping 72 matching lines @@
         else {
             name.append('-');
             name.append(WTF::toASCIILower(c));
         }
     }
 
     return String::adopt(name);
 }
 
 NAMED_PROPERTY_GETTER(CSSStyleDeclaration) {
-  INC_STATS(L"DOM.CSSStyleDeclaration.NamedPropertyGetter");
+  INC_STATS("DOM.CSSStyleDeclaration.NamedPropertyGetter");
   // First look for API defined attributes on the style declaration
   // object.
   if (info.Holder()->HasRealNamedCallbackProperty(name))
     return v8::Handle<v8::Value>();
 
   // Search the style declaration.
   CSSStyleDeclaration* imp = V8Proxy::ToNativeObject<CSSStyleDeclaration>(
       V8ClassIndex::CSSSTYLEDECLARATION, info.Holder());
 
   bool pixel_or_pos;
@@ skipping 23 matching lines @@
   // The 'filter' attribute is made undetectable in KJS/WebKit
   // to avoid confusion with IE's filter extension.
   if (prop == "filter") {
     return v8UndetectableString(result);
   }
   return v8String(result);
 }
 
 
 NAMED_PROPERTY_SETTER(CSSStyleDeclaration) {
-  INC_STATS(L"DOM.CSSStyleDeclaration.NamedPropertySetter");
+  INC_STATS("DOM.CSSStyleDeclaration.NamedPropertySetter");
   CSSStyleDeclaration* imp = V8Proxy::ToNativeObject<CSSStyleDeclaration>(
       V8ClassIndex::CSSSTYLEDECLARATION, info.Holder());
   String property_name = ToWebCoreString(name);
   int ec = 0;
 
   bool pixel_or_pos;
   String prop = cssPropertyName(property_name, &pixel_or_pos);
   if (!CSSStyleDeclaration::isPropertyName(prop)) {
     return v8::Handle<v8::Value>();  // do not block the call
   }
 
   String prop_value = valueToStringWithNullCheck(value);
   if (pixel_or_pos) prop_value += "px";
   imp->setProperty(prop, prop_value, ec);
 
   V8Proxy::SetDOMException(ec);
   return value;
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLPlugInElement) {
-  INC_STATS(L"DOM.HTMLPlugInElement.NamedPropertyGetter");
+  INC_STATS("DOM.HTMLPlugInElement.NamedPropertyGetter");
   HTMLPlugInElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLPlugInElement>(info.Holder());
   v8::Local<v8::Object> instance =
       v8::Local<v8::Object>::New(imp->getInstance());
   if (instance.IsEmpty()) return v8::Handle<v8::Object>();
   return NPObjectGetNamedProperty(instance, name);
 }
 
 
 NAMED_PROPERTY_SETTER(HTMLPlugInElement) {
-  INC_STATS(L"DOM.HTMLPlugInElement.NamedPropertySetter");
+  INC_STATS("DOM.HTMLPlugInElement.NamedPropertySetter");
   HTMLPlugInElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLPlugInElement>(info.Holder());
   v8::Local<v8::Object> instance =
       v8::Local<v8::Object>::New(imp->getInstance());
   if (instance.IsEmpty()) {
     return v8::Handle<v8::Value>();  // do not block the call
   }
 
   return NPObjectSetNamedProperty(instance, name, value);
 }
 
 
 CALLBACK_FUNC_DECL(HTMLPlugInElement) {
-  INC_STATS(L"DOM.HTMLPluginElement()");
+  INC_STATS("DOM.HTMLPluginElement()");
   return NPObjectInvokeDefaultHandler(args);
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLPlugInElement) {
-  INC_STATS(L"DOM.HTMLPlugInElement.IndexedPropertyGetter");
+  INC_STATS("DOM.HTMLPlugInElement.IndexedPropertyGetter");
   HTMLPlugInElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLPlugInElement>(info.Holder());
   v8::Local<v8::Object> instance =
       v8::Local<v8::Object>::New(imp->getInstance());
   if (instance.IsEmpty()) return v8::Handle<v8::Object>();
   return NPObjectGetIndexedProperty(instance, index);
 }
 
 
 INDEXED_PROPERTY_SETTER(HTMLPlugInElement) {
-  INC_STATS(L"DOM.HTMLPlugInElement.IndexedPropertySetter");
+  INC_STATS("DOM.HTMLPlugInElement.IndexedPropertySetter");
   HTMLPlugInElement* imp =
       V8Proxy::DOMWrapperToNode<HTMLPlugInElement>(info.Holder());
   v8::Local<v8::Object> instance =
       v8::Local<v8::Object>::New(imp->getInstance());
   if (instance.IsEmpty()) {
     return v8::Handle<v8::Value>();  // do not block the call
   }
 
   return NPObjectSetIndexedProperty(instance, index, value);
 }
 
 NAMED_PROPERTY_GETTER(StyleSheetList) {
-  INC_STATS(L"DOM.StyleSheetList.NamedPropertyGetter");
+  INC_STATS("DOM.StyleSheetList.NamedPropertyGetter");
   // Look for local properties first.
   if (info.Holder()->HasRealNamedProperty(name)) {
     return v8::Handle<v8::Value>();
   }
 
   // Search style sheet.
   StyleSheetList* imp = V8Proxy::ToNativeObject<StyleSheetList>(
       V8ClassIndex::STYLESHEETLIST, info.Holder());
   String key = ToWebCoreString(name);
   HTMLStyleElement* item = imp->getNamedItem(key);
   if (item) {
     return V8Proxy::ToV8Object(V8ClassIndex::HTMLSTYLEELEMENT, item);
   }
   return v8::Handle<v8::Value>();
 }
 
 
 // CanvasRenderingContext2D ----------------------------------------------------
 
 // Helper macro for converting v8 values into floats (expected by many of the
 // canvas functions).
 #define TO_FLOAT(a) static_cast<float>((a)->NumberValue())
 
 // TODO: SetStrokeColor and SetFillColor are similar except function names,
 // consolidate them into one.
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DSetStrokeColor) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.setStrokeColor()");
+  INC_STATS("DOM.CanvasRenderingContext2D.setStrokeColor()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
   switch (args.Length()) {
     case 1:
       if (args[0]->IsString()) {
         context->setStrokeColor(ToWebCoreString(args[0]));
       } else {
         context->setStrokeColor(TO_FLOAT(args[0]));
       }
@@ skipping 22 matching lines @@
       break;
     default:
       V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                           "setStrokeColor: Invalid number of arguments");
       break;
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DSetFillColor) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.steFillColor()");
+  INC_STATS("DOM.CanvasRenderingContext2D.steFillColor()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
   switch (args.Length()) {
     case 1:
       if (args[0]->IsString()) {
         context->setFillColor(ToWebCoreString(args[0]));
       } else {
         context->setFillColor(TO_FLOAT(args[0]));
       }
@@ skipping 20 matching lines @@
       break;
     default:
       V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                           "setFillColor: Invalid number of arguments");
       break;
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DStrokeRect) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.strokeRect()");
+  INC_STATS("DOM.CanvasRenderingContext2D.strokeRect()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
   if (args.Length() == 5) {
     context->strokeRect(TO_FLOAT(args[0]),
                         TO_FLOAT(args[1]),
                         TO_FLOAT(args[2]),
                         TO_FLOAT(args[3]),
                         TO_FLOAT(args[4]));
   } else if (args.Length() == 4) {
     context->strokeRect(TO_FLOAT(args[0]),
                         TO_FLOAT(args[1]),
                         TO_FLOAT(args[2]),
                         TO_FLOAT(args[3]));
   } else {
     V8Proxy::SetDOMException(INDEX_SIZE_ERR);
     return v8::Handle<v8::Value>();
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DSetShadow) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.setShadow()");
+  INC_STATS("DOM.CanvasRenderingContext2D.setShadow()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   switch (args.Length()) {
     case 3:
       context->setShadow(TO_FLOAT(args[0]), TO_FLOAT(args[1]),
                          TO_FLOAT(args[2]));
       break;
     case 4:
@@ skipping 29 matching lines @@
     default:
       V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                           "setShadow: Invalid number of arguments");
       break;
   }
 
     return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DDrawImage) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.drawImage()");
+  INC_STATS("DOM.CanvasRenderingContext2D.drawImage()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   v8::Handle<v8::Value> arg = args[0];
 
   if (V8HTMLImageElement::HasInstance(arg)) {
     ExceptionCode ec = 0;
     HTMLImageElement* image_element =
         V8Proxy::DOMWrapperToNode<HTMLImageElement>(arg);
@@ skipping 64 matching lines @@
       return v8::Undefined();
     }
     return v8::Undefined();
   }
 
   V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
   return v8::Handle<v8::Value>();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DDrawImageFromRect) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.drawImageFromRect()");
+  INC_STATS("DOM.CanvasRenderingContext2D.drawImageFromRect()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   v8::Handle<v8::Value> arg = args[0];
 
   if (V8HTMLImageElement::HasInstance(arg)) {
     HTMLImageElement* image_element =
         V8Proxy::DOMWrapperToNode<HTMLImageElement>(arg);
     context->drawImageFromRect(image_element,
                                TO_FLOAT(args[1]), TO_FLOAT(args[2]),
                                TO_FLOAT(args[3]), TO_FLOAT(args[4]),
                                TO_FLOAT(args[5]), TO_FLOAT(args[6]),
                                TO_FLOAT(args[7]), TO_FLOAT(args[8]),
                                ToWebCoreString(args[9]));
   } else {
     V8Proxy::ThrowError(V8Proxy::TYPE_ERROR,
                         "drawImageFromRect: Invalid type of arguments");
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DCreatePattern) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.createPattern()");
+  INC_STATS("DOM.CanvasRenderingContext2D.createPattern()");
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   v8::Handle<v8::Value> arg = args[0];
 
   if (V8HTMLImageElement::HasInstance(arg)) {
     HTMLImageElement* image_element =
         V8Proxy::DOMWrapperToNode<HTMLImageElement>(arg);
     ExceptionCode ec = 0;
@@ skipping 19 matching lines @@
     }
     return V8Proxy::ToV8Object(V8ClassIndex::CANVASPATTERN,
                                static_cast<Peerable*>(pattern.get()));
   }
 
   V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
   return v8::Handle<v8::Value>();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DFillText) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.fillText()");
+  INC_STATS("DOM.CanvasRenderingContext2D.fillText()");
 
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   // Two forms:
   // * fillText(text, x, y)
   // * fillText(text, x, y, maxWidth)
   if (args.Length() < 3 || args.Length() > 4) {
     V8Proxy::SetDOMException(SYNTAX_ERR);
     return v8::Handle<v8::Value>();
   }
 
   String text = ToWebCoreString(args[0]);
   float x = TO_FLOAT(args[1]);
   float y = TO_FLOAT(args[2]);
 
   if (args.Length() == 4) {
     float maxWidth = TO_FLOAT(args[3]);
     context->fillText(text, x, y, maxWidth);
   } else {
     context->fillText(text, x, y);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DStrokeText) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.strokeText()");
+  INC_STATS("DOM.CanvasRenderingContext2D.strokeText()");
 
   CanvasRenderingContext2D* context =
       V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   // Two forms:
   // * strokeText(text, x, y)
   // * strokeText(text, x, y, maxWidth)
   if (args.Length() < 3 || args.Length() > 4) {
     V8Proxy::SetDOMException(SYNTAX_ERR);
     return v8::Handle<v8::Value>();
   }
 
   String text = ToWebCoreString(args[0]);
   float x = TO_FLOAT(args[1]);
   float y = TO_FLOAT(args[2]);
 
   if (args.Length() == 4) {
     float maxWidth = TO_FLOAT(args[3]);
     context->strokeText(text, x, y, maxWidth);
   } else {
     context->strokeText(text, x, y);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DPutImageData) {
-  INC_STATS(L"DOM.CanvasRenderingContext2D.putImageData()");
+  INC_STATS("DOM.CanvasRenderingContext2D.putImageData()");
   
   // Two froms:
   // * putImageData(ImageData, x, y)
   // * putImageData(ImageData, x, y, dirtyX, dirtyY, dirtyWidth, dirtyHeight)
   if (args.Length() != 3 && args.Length() != 7) {
     V8Proxy::SetDOMException(SYNTAX_ERR);
     return v8::Handle<v8::Value>();
   }
 
   CanvasRenderingContext2D* context =
@@ skipping 26 matching lines @@
     return v8::Handle<v8::Value>();
   }
 
   return v8::Undefined();
 }
 
 
 // Console ---------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(ConsoleAssert) {
-  INC_STATS(L"DOM.Console.assert()");
+  INC_STATS("DOM.Console.assert()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleCount) {
-  INC_STATS(L"DOM.Console.count()");
+  INC_STATS("DOM.Console.count()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleDebug) {
-  INC_STATS(L"DOM.Console.debug()");
+  INC_STATS("DOM.Console.debug()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleDir) {
-  INC_STATS(L"DOM.Console.dir()");
+  INC_STATS("DOM.Console.dir()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleError) {
-  INC_STATS(L"DOM.Console.error()");
+  INC_STATS("DOM.Console.error()");
   v8::Handle<v8::Value> holder = args.Holder();
   Console* imp = V8Proxy::ToNativeObject<Console>(V8ClassIndex::CONSOLE, holder);
   ScriptCallContext context(args);
   imp->error(&context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleGroup) {
-  INC_STATS(L"DOM.Console.group()");
+  INC_STATS("DOM.Console.group()");
   v8::Handle<v8::Value> holder = args.Holder();
   Console* imp = V8Proxy::ToNativeObject<Console>(V8ClassIndex::CONSOLE, holder);
   ScriptCallContext context(args);
   imp->group(&context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleInfo) {
-  INC_STATS(L"DOM.Console.info()");
+  INC_STATS("DOM.Console.info()");
   v8::Handle<v8::Value> holder = args.Holder();
   Console* imp = V8Proxy::ToNativeObject<Console>(V8ClassIndex::CONSOLE, holder);
   ScriptCallContext context(args);
   imp->info(&context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleLog) {
-  INC_STATS(L"DOM.Console.log()");
+  INC_STATS("DOM.Console.log()");
   v8::Handle<v8::Value> holder = args.Holder();
   Console* imp = V8Proxy::ToNativeObject<Console>(V8ClassIndex::CONSOLE, holder);
   ScriptCallContext context(args);
   imp->log(&context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleProfile) {
-  INC_STATS(L"DOM.Console.profile()");
+  INC_STATS("DOM.Console.profile()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleProfileEnd) {
-  INC_STATS(L"DOM.Console.profileEnd()");
+  INC_STATS("DOM.Console.profileEnd()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleTimeEnd) {
-  INC_STATS(L"DOM.Console.timeEnd()");
+  INC_STATS("DOM.Console.timeEnd()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleWarn) {
-  INC_STATS(L"DOM.Console.warn()");
+  INC_STATS("DOM.Console.warn()");
   v8::Handle<v8::Value> holder = args.Holder();
   Console* imp = V8Proxy::ToNativeObject<Console>(V8ClassIndex::CONSOLE, holder);
   ScriptCallContext context(args);
   imp->warn(&context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleDirxml) {
-  INC_STATS(L"DOM.Console.dirxml()");
+  INC_STATS("DOM.Console.dirxml()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ConsoleTrace) {
-  INC_STATS(L"DOM.Console.trace()");
+  INC_STATS("DOM.Console.trace()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 
 // Clipboard -------------------------------------------------------------------
 
 
 ACCESSOR_GETTER(ClipboardTypes) {
-  INC_STATS(L"DOM.Clipboard.types()");
+  INC_STATS("DOM.Clipboard.types()");
   Clipboard* imp =
     V8Proxy::ToNativeObject<Clipboard>(V8ClassIndex::CLIPBOARD,
                                        info.Holder());
 
   HashSet<String> types = imp->types();
   if (types.isEmpty())
     return v8::Null();
 
   v8::Local<v8::Array> result = v8::Array::New(types.size());
   HashSet<String>::const_iterator end = types.end();
   int index = 0;
   for (HashSet<String>::const_iterator it = types.begin();
        it != end;
        ++it, ++index) {
     result->Set(v8::Integer::New(index), v8String(*it));
   }
   return result;
 }
 
 
 CALLBACK_FUNC_DECL(ClipboardClearData) {
-  INC_STATS(L"DOM.Clipboard.clearData()");
+  INC_STATS("DOM.Clipboard.clearData()");
   Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
 
   if (args.Length() == 0) {
     imp->clearAllData();
     return v8::Undefined();
   } 
 
   if (args.Length() == 1) {
     String v = ToWebCoreString(args[0]);
     imp->clearData(v);
     return v8::Undefined();
   }
   
   V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                       "clearData: Invalid number of arguments");
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(ClipboardGetData) {
-  INC_STATS(L"DOM.Clipboard.getData()");
+  INC_STATS("DOM.Clipboard.getData()");
   Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
   
   if (args.Length() != 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                         "getData: Invalid number of arguments");
     return v8::Undefined();
   }
 
   bool success;
   String v = ToWebCoreString(args[0]);
   String result = imp->getData(v, success);
   if (success) return v8String(result);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ClipboardSetData) {
-  INC_STATS(L"DOM.Clipboard.setData()");
+  INC_STATS("DOM.Clipboard.setData()");
   Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
 
   if (args.Length() != 2) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                         "setData: Invalid number of arguments");
     return v8::Undefined();
   }
 
   String type = ToWebCoreString(args[0]);
   String data = ToWebCoreString(args[1]);
   bool result = imp->setData(type, data);
   return result ? v8::True() : v8::False();
 }
 
 
 CALLBACK_FUNC_DECL(ClipboardSetDragImage) {
-  INC_STATS(L"DOM.Clipboard.setDragImage()");
+  INC_STATS("DOM.Clipboard.setDragImage()");
   Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
   
   if (!imp->isForDragging())
     return v8::Undefined();
 
   if (args.Length() != 3) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                         "setDragImage: Invalid number of arguments");
     return v8::Undefined();
@@ skipping 59 matching lines @@
     if (contentDoc && !V8Proxy::CheckNodeSecurity(contentDoc))
       return false;
   }
   return true;
 }
 
 
 // Element ---------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(ElementSetAttribute) {
-  INC_STATS(L"DOM.Element.setAttribute()");
+  INC_STATS("DOM.Element.setAttribute()");
   Element* imp = V8Proxy::DOMWrapperToNode<Element>(args.Holder());
   ExceptionCode ec = 0;
   String name = ToWebCoreString(args[0]);
   String value = ToWebCoreString(args[1]);
 
   if (!AllowSettingSrcToJavascriptURL(imp, name, value)) {
     return v8::Undefined();
   }
 
   imp->setAttribute(name, value, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ElementSetAttributeNode) {
-  INC_STATS(L"DOM.Element.setAttributeNode()");
+  INC_STATS("DOM.Element.setAttributeNode()");
   if (!V8Attr::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Handle<v8::Value>();
   }
 
   Attr* newAttr = V8Proxy::DOMWrapperToNode<Attr>(args[0]);
   Element* imp = V8Proxy::DOMWrapperToNode<Element>(args.Holder());
   ExceptionCode ec = 0;
 
   if (!AllowSettingSrcToJavascriptURL(imp, newAttr->name(), newAttr->value())) {
     return v8::Undefined();
   }
 
   RefPtr<Attr> result = imp->setAttributeNode(newAttr, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(ElementSetAttributeNS) {
-  INC_STATS(L"DOM.Element.setAttributeNS()");
+  INC_STATS("DOM.Element.setAttributeNS()");
   Element* imp = V8Proxy::DOMWrapperToNode<Element>(args.Holder());
   ExceptionCode ec = 0;
   String namespaceURI = valueToStringWithNullCheck(args[0]);
   String qualifiedName = ToWebCoreString(args[1]);
   String value = ToWebCoreString(args[2]);
 
   if (!AllowSettingSrcToJavascriptURL(imp, qualifiedName, value)) {
     return v8::Undefined();
   }
 
   imp->setAttributeNS(namespaceURI, qualifiedName, value, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ElementSetAttributeNodeNS) {
-  INC_STATS(L"DOM.Element.setAttributeNodeNS()");
+  INC_STATS("DOM.Element.setAttributeNodeNS()");
   if (!V8Attr::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Handle<v8::Value>();
   }
 
   Attr* newAttr = V8Proxy::DOMWrapperToNode<Attr>(args[0]);
   Element* imp = V8Proxy::DOMWrapperToNode<Element>(args.Holder());
   ExceptionCode ec = 0;
 
   if (!AllowSettingSrcToJavascriptURL(imp, newAttr->name(), newAttr->value())) {
@@ skipping 119 matching lines @@
     id = imp->installTimeout(action, timeout, single_shot);
   } else {
     // TODO(fqian): what's the right return value if failed.
     return v8::Undefined();
   }
   return v8::Integer::New(id);
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowSetTimeout) {
-  INC_STATS(L"DOM.DOMWindow.setTimeout()");
+  INC_STATS("DOM.DOMWindow.setTimeout()");
   return WindowSetTimeoutImpl(args, true);
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowSetInterval) {
-  INC_STATS(L"DOM.DOMWindow.setInterval()");
+  INC_STATS("DOM.DOMWindow.setInterval()");
   return WindowSetTimeoutImpl(args, false);
 }
 
 
 // HTMLDocument ----------------------------------------------------------------
 
 // Concatenates "args" to a string. If args is empty, returns empty string.
 // Firefox/Safari/IE support non-standard arguments to document.write, ex:
 //   document.write("a", "b", "c") --> document.write("abc")
 //   document.write() --> document.write("")
 static String WriteHelper_GetString(const v8::Arguments& args) {
   String str = "";
   for (int i = 0; i < args.Length(); ++i) {
     str += ToWebCoreString(args[i]);
   }
   return str;
 }
 
 CALLBACK_FUNC_DECL(HTMLDocumentWrite) {
-  INC_STATS(L"DOM.HTMLDocument.write()");
+  INC_STATS("DOM.HTMLDocument.write()");
   HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(args.Holder());
   Frame* frame = V8Proxy::retrieveActiveFrame();
   ASSERT(frame);
   imp->write(WriteHelper_GetString(args), frame->document());
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(HTMLDocumentWriteln) {
-  INC_STATS(L"DOM.HTMLDocument.writeln()");
+  INC_STATS("DOM.HTMLDocument.writeln()");
   HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(args.Holder());
   Frame* frame = V8Proxy::retrieveActiveFrame();
   ASSERT(frame);
   imp->writeln(WriteHelper_GetString(args), frame->document());
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(HTMLDocumentOpen) {
-  INC_STATS(L"DOM.HTMLDocument.open()");
+  INC_STATS("DOM.HTMLDocument.open()");
   HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(args.Holder());
 
   if (args.Length() > 2) {
     if (Frame* frame = imp->frame()) {
       // Fetch the global object for the frame.
       v8::Local<v8::Context> context = V8Proxy::GetContext(frame);
       // Bail out if we cannot get the context.
       if (context.IsEmpty()) return v8::Undefined();
       v8::Local<v8::Object> global = context->Global();
       // Get the open property of the global object.
@@ skipping 21 matching lines @@
   }
 
   Frame* frame = V8Proxy::retrieveActiveFrame();
   imp->open(frame->document());
   return v8::Undefined();
 }
 
 // Document --------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(DocumentEvaluate) {
-  INC_STATS(L"DOM.Document.evaluate()");
+  INC_STATS("DOM.Document.evaluate()");
 
   Document* imp = V8Proxy::DOMWrapperToNode<Document>(args.Holder());
   ExceptionCode ec = 0;
   String expression = ToWebCoreString(args[0]);
   Node* contextNode = NULL;
   if (V8Node::HasInstance(args[1])) {
     contextNode = V8Proxy::DOMWrapperToNode<Node>(args[1]);
   }
   // Find the XPath
   XPathNSResolver* resolver = NULL;
@@ skipping 54 matching lines @@
     if (!base64Decode(in, out)) {
       V8Proxy::ThrowError(V8Proxy::GENERAL_ERROR, "Cannot decode base64");
       return v8::Undefined();
     }
   }
 
   return v8String(String(out.data(), out.size()));
 }
 
 CALLBACK_FUNC_DECL(DOMWindowAtob) {
-  INC_STATS(L"DOM.DOMWindow.atob()");
+  INC_STATS("DOM.DOMWindow.atob()");
   DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   if (!V8Proxy::CanAccessFrame(imp->frame(), true))
     return v8::Undefined();
 
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
   if (args[0]->IsNull()) return v8String("");
 
   String str = ToWebCoreString(args[0]);
   return Base64Convert(str, false);
 }
 
 CALLBACK_FUNC_DECL(DOMWindowBtoa) {
-  INC_STATS(L"DOM.DOMWindow.btoa()");
+  INC_STATS("DOM.DOMWindow.btoa()");
   DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   if (!V8Proxy::CanAccessFrame(imp->frame(), true))
     return v8::Undefined();
 
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
   if (args[0]->IsNull()) return v8String("");
 
   String str = ToWebCoreString(args[0]);
   return Base64Convert(str, true);
 }
 
 // TODO(fqian): returning string is cheating, and we should
 // fix this by calling toString function on the receiver.
 // However, V8 implements toString in JavaScript, which requires
 // switching context of receiver. I consider it is dangerous.
 CALLBACK_FUNC_DECL(DOMWindowToString)
 {
-    INC_STATS(L"DOM.DOMWindow.toString()");
+    INC_STATS("DOM.DOMWindow.toString()");
     return args.This()->ObjectProtoToString();
 }
 
 CALLBACK_FUNC_DECL(DOMWindowNOP)
 {
-    INC_STATS(L"DOM.DOMWindow.nop()");
+    INC_STATS("DOM.DOMWindow.nop()");
     return v8::Undefined();
 }
 
 
 // EventTargetNode -------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(EventTargetNodeAddEventListener) {
-  INC_STATS(L"DOM.EventTargetNode.addEventListener()");
+  INC_STATS("DOM.EventTargetNode.addEventListener()");
   EventTargetNode* node =
       V8Proxy::DOMWrapperToNode<EventTargetNode>(args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(node->document()->frame());
   if (!proxy)
     return v8::Undefined();
 
   RefPtr<EventListener> listener =
     proxy->FindOrCreateV8EventListener(args[1], false);
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     node->addEventListener(type, listener, useCapture);
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(EventTargetNodeRemoveEventListener) {
-  INC_STATS(L"DOM.EventTargetNode.removeEventListener()");
+  INC_STATS("DOM.EventTargetNode.removeEventListener()");
   EventTargetNode* node =
       V8Proxy::DOMWrapperToNode<EventTargetNode>(args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(node->document()->frame());
   // It is possbile that the owner document of the node is detached
   // from the frame, return immediately in this case.
   // See issue 878909
   if (!proxy)
     return v8::Undefined();
 
   RefPtr<EventListener> listener =
     proxy->FindV8EventListener(args[1], false);
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     node->removeEventListener(type, listener.get(), useCapture);
   }
 
   return v8::Undefined();
 }
 
 
 // Navigator ------------------------------------------------------------------
 ACCESSOR_GETTER(NavigatorAppVersion) {
-  INC_STATS(L"DOM.Navigator.appVersion");
+  INC_STATS("DOM.Navigator.appVersion");
   v8::Handle<v8::Object> holder = info.Holder();
   Navigator* imp = V8Proxy::ToNativeObject<Navigator>(V8ClassIndex::NAVIGATOR,
                                                       holder);
   String v = ToString(imp->appVersion());
   return v8StringOrUndefined(v);
 }
 
 
 // TreeWalker ------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(TreeWalkerParentNode) {
-  INC_STATS(L"DOM.TreeWalker.parentNode()");
+  INC_STATS("DOM.TreeWalker.parentNode()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->parentNode(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerFirstChild) {
-  INC_STATS(L"DOM.TreeWalker.firstChild()");
+  INC_STATS("DOM.TreeWalker.firstChild()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->firstChild(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerLastChild) {
-  INC_STATS(L"DOM.TreeWalker.lastChild()");
+  INC_STATS("DOM.TreeWalker.lastChild()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->lastChild(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextNode) {
-  INC_STATS(L"DOM.TreeWalker.nextNode()");
+  INC_STATS("DOM.TreeWalker.nextNode()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->nextNode(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousNode) {
-  INC_STATS(L"DOM.TreeWalker.previousNode()");
+  INC_STATS("DOM.TreeWalker.previousNode()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->previousNode(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextSibling) {
-  INC_STATS(L"DOM.TreeWalker.nextSibling()");
+  INC_STATS("DOM.TreeWalker.nextSibling()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->nextSibling(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousSibling) {
-  INC_STATS(L"DOM.TreeWalker.previousSibling()");
+  INC_STATS("DOM.TreeWalker.previousSibling()");
   TreeWalker* treeWalker = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
 
   JSC::ExecState exec;
   RefPtr<Node> result = treeWalker->previousSibling(&exec);
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorNextNode) {
-  INC_STATS(L"DOM.NodeIterator.nextNode()");
+  INC_STATS("DOM.NodeIterator.nextNode()");
   NodeIterator* nodeIterator = V8Proxy::ToNativeObject<NodeIterator>(
       V8ClassIndex::NODEITERATOR, args.Holder());
 
   ExceptionCode ec = 0;
   JSC::ExecState exec;
   RefPtr<Node> result = nodeIterator->nextNode(&exec, ec);
   if (ec != 0) {
       V8Proxy::SetDOMException(ec);
       return v8::Null();
   }
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorPreviousNode) {
-  INC_STATS(L"DOM.NodeIterator.previousNode()");
+  INC_STATS("DOM.NodeIterator.previousNode()");
   NodeIterator* nodeIterator = V8Proxy::ToNativeObject<NodeIterator>(
       V8ClassIndex::NODEITERATOR, args.Holder());
 
   ExceptionCode ec = 0;
   JSC::ExecState exec;
   RefPtr<Node> result = nodeIterator->previousNode(&exec, ec);
   if (ec != 0) {
       V8Proxy::SetDOMException(ec);
       return v8::Null();
   }
   if (exec.hadException()) {
     v8::ThrowException(exec.exception());
     return v8::Undefined();
   }
   if (!result) return v8::Null();
   return V8Proxy::NodeToV8Object(result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeFilterAcceptNode) {
-  INC_STATS(L"DOM.NodeFilter.acceptNode()");
+  INC_STATS("DOM.NodeFilter.acceptNode()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);  
   return v8::Undefined();
 }
 
 static String EventNameFromAttributeName(const String& name) {
   ASSERT(name.startsWith("on"));
   String event_type = name.substring(2);
 
   if (event_type.startsWith("w")) {
     switch(event_type[event_type.length() - 1]) {
@@ skipping 134 matching lines @@
       newLength = UINT_MAX;
     } else {
       newLength = static_cast<unsigned>(v);
     }
   }
   if (!ec) imp->setLength(value->Uint32Value(), ec);
   V8Proxy::SetDOMException(ec);
 }
 
 ACCESSOR_GETTER(HTMLInputElementSelectionStart) {
-  INC_STATS(L"DOM.HTMLInputElement.selectionStart._get");
+  INC_STATS("DOM.HTMLInputElement.selectionStart._get");
   v8::Handle<v8::Object> holder = info.Holder();
   HTMLInputElement* imp = V8Proxy::DOMWrapperToNode<HTMLInputElement>(holder);
 
   if (!imp->canHaveSelection())
     return v8::Undefined();
 
   int v = imp->selectionStart();
   return v8::Integer::New(v);
 }
 
 ACCESSOR_GETTER(HTMLInputElementSelectionEnd) {
-  INC_STATS(L"DOM.HTMLInputElement.selectionEnd._get");
+  INC_STATS("DOM.HTMLInputElement.selectionEnd._get");
   v8::Handle<v8::Object> holder = info.Holder();
   HTMLInputElement* imp = V8Proxy::DOMWrapperToNode<HTMLInputElement>(holder);
 
   if (!imp->canHaveSelection())
     return v8::Undefined();
 
   int v = imp->selectionEnd();
   return v8::Integer::New(v);
 }
 
 #if ENABLE(SVG)
 
 ACCESSOR_GETTER(SVGLengthValue) {
-  INC_STATS(L"DOM.SVGLength.value");
+  INC_STATS("DOM.SVGLength.value");
   V8SVGPODTypeWrapper<SVGLength>* wrapper = V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<SVGLength> >(V8ClassIndex::SVGLENGTH, info.Holder());
   SVGLength imp = *wrapper;
   return v8::Number::New(imp.value(V8Proxy::GetSVGContext(wrapper)));
 }
 
 CALLBACK_FUNC_DECL(SVGLengthConvertToSpecifiedUnits) {
-  INC_STATS(L"DOM.SVGLength.convertToSpecifiedUnits");
+  INC_STATS("DOM.SVGLength.convertToSpecifiedUnits");
   V8SVGPODTypeWrapper<SVGLength>* wrapper = V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<SVGLength> >(V8ClassIndex::SVGLENGTH, args.Holder());
   SVGLength imp = *wrapper;
   SVGElement* context = V8Proxy::GetSVGContext(wrapper);
   imp.convertToSpecifiedUnits(ToInt32(args[0]), context);
   wrapper->commitChange(imp, context);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(SVGMatrixInverse) {
-  INC_STATS(L"DOM.SVGMatrix.inverse()");
+  INC_STATS("DOM.SVGMatrix.inverse()");
   AffineTransform imp =
       *V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<AffineTransform> >(
           V8ClassIndex::SVGMATRIX, args.Holder());
   ExceptionCode ec = 0;
   AffineTransform result = imp.inverse();
   if (!imp.isInvertible()) {
     ec = SVGException::SVG_MATRIX_NOT_INVERTABLE;
   }
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
 
   Peerable* peer = static_cast<Peerable*>(
       new V8SVGStaticPODTypeWrapper<AffineTransform>(result));
   return V8Proxy::ToV8Object(V8ClassIndex::SVGMATRIX, peer);
 }
 
 CALLBACK_FUNC_DECL(SVGMatrixRotateFromVector) {
-  INC_STATS(L"DOM.SVGMatrix.rotateFromVector()");
+  INC_STATS("DOM.SVGMatrix.rotateFromVector()");
   AffineTransform imp =
       *V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<AffineTransform> >(
           V8ClassIndex::SVGMATRIX, args.Holder());
   ExceptionCode ec = 0;
   float x = TO_FLOAT(args[0]);
   float y = TO_FLOAT(args[1]);
   AffineTransform result = imp;
   result.rotateFromVector(x, y);
   if (x == 0.0 || y == 0.0) {
     ec = SVGException::SVG_INVALID_VALUE_ERR;
   }
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
 
   Peerable* peer = static_cast<Peerable*>(
       new V8SVGStaticPODTypeWrapper<AffineTransform>(result));
   return V8Proxy::ToV8Object(V8ClassIndex::SVGMATRIX, peer);
 }
 
 CALLBACK_FUNC_DECL(SVGElementInstanceAddEventListener) {
-  INC_STATS(L"DOM.SVGElementInstance.AddEventListener()");
+  INC_STATS("DOM.SVGElementInstance.AddEventListener()");
   SVGElementInstance* instance =
       V8Proxy::DOMWrapperToNative<SVGElementInstance>(args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(instance->scriptExecutionContext());
   if (!proxy)
     return v8::Undefined();
 
   RefPtr<EventListener> listener =
     proxy->FindOrCreateV8EventListener(args[1], false);
   if (listener) {
     String type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     instance->addEventListener(type, listener, useCapture);
   }
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(SVGElementInstanceRemoveEventListener) {
-  INC_STATS(L"DOM.SVGElementInstance.RemoveEventListener()");
+  INC_STATS("DOM.SVGElementInstance.RemoveEventListener()");
   SVGElementInstance* instance =
       V8Proxy::DOMWrapperToNative<SVGElementInstance>(args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(instance->scriptExecutionContext());
   // It is possbile that the owner document of the node is detached
   // from the frame, return immediately in this case.
   // See issue 878909
   if (!proxy)
     return v8::Undefined();
 
@@ skipping 180 matching lines @@
 #undef MAKE_CASE
 
   default:
     return V8ClassIndex::INVALID_CLASS_INDEX;
   }
 }
 
 #endif  // ENABLE(SVG)
 
 }  // namespace WebCore