Use static type information from IDL to streamline the wrapping and unwrappin...

webkit/port/bindings/v8/v8_custom.cpp

 /*
  *  This file is part of the KDE libraries
  *  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 Google Inc. All Rights Reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ skipping 301 matching lines @@
                                      XSLTProcessor>(args);
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorImportStylesheet) {
   INC_STATS(L"DOM.XSLTProcessor.importStylesheet");
   // Return undefined if argument does not have the correct type.
   if (!V8Node::HasInstance(args[0]))
     return v8::Undefined();
 
-  XSLTProcessor* imp = V8Proxy::FastToNativeObject<XSLTProcessor>(
+  XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
-  Node* node = V8Proxy::FastToNativeObject<Node>(V8ClassIndex::NODE, args[0]);
+  Node* node = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   imp->importStylesheet(node);
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorTransformToFragment) {
   INC_STATS(L"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::FastToNativeObject<XSLTProcessor>(
+  XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
-  Node* source = V8Proxy::FastToNativeObject<Node>(V8ClassIndex::NODE, args[0]);
+  Node* source = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   Document* owner =
-      V8Proxy::FastToNativeObject<Document>(V8ClassIndex::NODE, args[1]);
+      V8Proxy::DOMWrapperToNode<Document>(args[1]);
   RefPtr<DocumentFragment> result = imp->transformToFragment(source, owner);
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorTransformToDocument) {
   INC_STATS(L"DOM.XSLTProcessor.transformToDocument");
   // Return undefined if argument does not have the correct type.
   if (!V8Node::HasInstance(args[0]))
     return v8::Undefined();
 
-  XSLTProcessor* imp = V8Proxy::FastToNativeObject<XSLTProcessor>(
+  XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
-  Node* source = V8Proxy::FastToNativeObject<Node>(V8ClassIndex::NODE, args[0]);
+  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::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 CALLBACK_FUNC_DECL(XSLTProcessorSetParameter) {
   INC_STATS(L"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::FastToNativeObject<XSLTProcessor>(
+  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");
   // Bail out if localName is null or undefined.
   if (args[1]->IsNull() || args[1]->IsUndefined()) {
     return v8::Undefined();
   }
 
-  XSLTProcessor* imp = V8Proxy::FastToNativeObject<XSLTProcessor>(
+  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");
   // Bail out if localName is null or undefined.
   if (args[1]->IsNull() || args[1]->IsUndefined()) {
     return v8::Undefined();
   }
 
-  XSLTProcessor* imp = V8Proxy::FastToNativeObject<XSLTProcessor>(
+  XSLTProcessor* imp = V8Proxy::ToNativeObject<XSLTProcessor>(
       V8ClassIndex::XSLTPROCESSOR, args.Holder());
 
   String namespaceURI = ToWebCoreString(args[0]);
   String localName = ToWebCoreString(args[1]);
   imp->removeParameter(namespaceURI, localName);
   return v8::Undefined();
 }
 
 
 // ---- Canvas support ----
 static v8::Handle<v8::Value> CanvasStyleToV8Object(CanvasStyle* style) {
   if (style->gradient()) {
     return V8Proxy::ToV8Object(V8ClassIndex::CANVASGRADIENT,
                                static_cast<Peerable*>(style->gradient()));
   }
   if (style->pattern()) {
     return V8Proxy::ToV8Object(V8ClassIndex::CANVASPATTERN,
                                static_cast<Peerable*>(style->pattern()));
   }
   return v8String(style->color());
 }
 
 
 static PassRefPtr<CanvasStyle> V8ObjectToCanvasStyle(
     v8::Handle<v8::Value> value) {
   if (value->IsString()) return new CanvasStyle(ToWebCoreString(value));
 
   if (V8CanvasGradient::HasInstance(value)) {
     CanvasGradient* gradient =
-        V8Proxy::FastDOMWrapperToNative<CanvasGradient>(value);
+        V8Proxy::DOMWrapperToNative<CanvasGradient>(value);
     return new CanvasStyle(gradient);
   }
 
   if (V8CanvasPattern::HasInstance(value)) {
     CanvasPattern* pattern =
-        V8Proxy::FastDOMWrapperToNative<CanvasPattern>(value);
+        V8Proxy::DOMWrapperToNative<CanvasPattern>(value);
     return new CanvasStyle(pattern);
   }
 
   return 0;
 }
 
 
 ACCESSOR_GETTER(CanvasRenderingContext2DStrokeStyle) {
   CanvasRenderingContext2D* impl =
-    V8Proxy::FastDOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
+    V8Proxy::DOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
   CanvasStyle* strokeStyle = impl->strokeStyle();
   return CanvasStyleToV8Object(strokeStyle);
 }
 
 
 ACCESSOR_SETTER(CanvasRenderingContext2DStrokeStyle) {
   CanvasRenderingContext2D* impl =
-    V8Proxy::FastDOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
+    V8Proxy::DOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
   impl->setStrokeStyle(V8ObjectToCanvasStyle(value));
 }
 
 ACCESSOR_GETTER(CanvasRenderingContext2DFillStyle) {
   CanvasRenderingContext2D* impl =
-    V8Proxy::FastDOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
+    V8Proxy::DOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
   CanvasStyle* fillStyle = impl->fillStyle();
   return CanvasStyleToV8Object(fillStyle);
 }
 
 
 ACCESSOR_SETTER(CanvasRenderingContext2DFillStyle) {
   CanvasRenderingContext2D* impl =
-    V8Proxy::FastDOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
+    V8Proxy::DOMWrapperToNative<CanvasRenderingContext2D>(info.Holder());
   impl->setFillStyle(V8ObjectToCanvasStyle(value));
 }
 
 
 // DOMImplementation is a singleton in WebCore.  If we use our normal
 // mapping from DOM objects to V8 wrappers, the same wrapper will be
 // shared for all frames in the same process.  This is a major
 // security problem.  Therefore, we generate a DOMImplementation
 // wrapper per document and store it in an internal field of the
 // document.  Since the DOMImplementation object is a singleton, we do
 // not have to do anything to keep the DOMImplementation object alive
 // for the lifetime of the wrapper.
 ACCESSOR_GETTER(DocumentImplementation) {
   ASSERT(info.Holder()->InternalFieldCount() >=
          kDocumentMinimumInternalFieldCount);
   // Check if the internal field already contains a wrapper.
   v8::Local<v8::Value> implementation =
       info.Holder()->GetInternalField(kDocumentImplementationIndex);
   if (!implementation->IsUndefined()) {
     return implementation;
   }
   // Generate a wrapper.
-  Document* doc = V8Proxy::FastDOMWrapperToNative<Document>(info.Holder());
+  Document* doc = V8Proxy::DOMWrapperToNative<Document>(info.Holder());
   v8::Handle<v8::Value> wrapper =
       V8Proxy::DOMImplementationToV8Object(doc->implementation());
   // Store the wrapper in the internal field.
   info.Holder()->SetInternalField(kDocumentImplementationIndex, wrapper);
 
   return wrapper;
 }
 
 
 ACCESSOR_GETTER(DocumentLocation) {
-  Document* imp = V8Proxy::FastDOMWrapperToNative<Document>(info.Holder());
+  Document* imp = V8Proxy::DOMWrapperToNative<Document>(info.Holder());
   if (!imp->frame())
     return v8::Null();
 
   DOMWindow* window = imp->frame()->domWindow();
   return V8Proxy::ToV8Object(V8ClassIndex::LOCATION,
                              static_cast<Peerable*>(window->location()));
 }
 
 
 ACCESSOR_SETTER(DocumentLocation) {
-  Document* imp = V8Proxy::FastDOMWrapperToNative<Document>(info.Holder());
+  Document* imp = V8Proxy::DOMWrapperToNative<Document>(info.Holder());
   if (!imp->frame())
     return;
 
   DOMWindow* window = imp->frame()->domWindow();
   // DOMWindow::setLocation does security checks.
   window->setLocation(ToWebCoreString(value));
 }
 
 
 ACCESSOR_SETTER(DOMWindowLocation) {
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return;
 
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, holder);
   imp->setLocation(ToWebCoreString(value));
 }
 
 
 ACCESSOR_SETTER(DOMWindowOpener) {
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, info.Holder());
 
   if (!V8Proxy::IsFromSameOrigin(imp->frame(), true))
     return;
   
   // Opener can be shadowed if it is in the same domain.
   // Have a special handling of null value to behave
   // like Firefox. See bug 1224887 & 791706.
   if (value->IsNull()) {
     // imp->frame() cannot be null,
     // otherwise, SameOrigin check would have failed.
     ASSERT(imp->frame());
     imp->frame()->loader()->setOpener(0);
   }
 
   // Delete the accessor from this object.
   info.Holder()->Delete(name);
 
   // Put property on the front (this) object.
   info.This()->Set(name, value);
 }
 
 
 ACCESSOR_GETTER(EventSrcElement) {
-  Event* event = V8Proxy::FastDOMWrapperToNative<Event>(info.Holder());
+  Event* event = V8Proxy::DOMWrapperToNative<Event>(info.Holder());
   EventTarget* target = event->target();
   return V8Proxy::EventTargetToV8Object(target);
 }
 
 
 ACCESSOR_GETTER(EventReturnValue) {
-  Event* event = V8Proxy::FastDOMWrapperToNative<Event>(info.Holder());
+  Event* event = V8Proxy::DOMWrapperToNative<Event>(info.Holder());
   return event->defaultPrevented() ? v8::False() : v8::True();
 }
 
 
 ACCESSOR_SETTER(EventReturnValue) {
-  Event* event = V8Proxy::FastDOMWrapperToNative<Event>(info.Holder());
+  Event* event = V8Proxy::DOMWrapperToNative<Event>(info.Holder());
   bool v = value->BooleanValue();
   event->setDefaultPrevented(!v);
 }
 
 
 ACCESSOR_GETTER(EventDataTransfer) {
-  Event* event = V8Proxy::FastDOMWrapperToNative<Event>(info.Holder());
+  Event* event = V8Proxy::DOMWrapperToNative<Event>(info.Holder());
 
   if (event->isDragEvent()) {
     MouseEvent* impl = static_cast<MouseEvent*>(event);
     Clipboard* clipboard = impl->clipboard();
     return V8Proxy::ToV8Object(V8ClassIndex::CLIPBOARD, clipboard);
   }
 
   return v8::Undefined();
 }
 
 
 ACCESSOR_GETTER(EventClipboardData) {
-  Event* event = V8Proxy::FastDOMWrapperToNative<Event>(info.Holder());
+  Event* event = V8Proxy::DOMWrapperToNative<Event>(info.Holder());
 
   if (event->isClipboardEvent()) {
     ClipboardEvent* impl = static_cast<ClipboardEvent*>(event);
     Clipboard* clipboard = impl->clipboard();
     return V8Proxy::ToV8Object(V8ClassIndex::CLIPBOARD, clipboard);
   }
 
   return v8::Undefined();
 }
 
 
 static v8::Handle<v8::Value> HTMLCollectionGetNamedItems(
     HTMLCollection* collection, String name) {
   Vector<RefPtr<Node> > namedItems;
   collection->namedItems(name, namedItems);
   switch (namedItems.size()) {
     case 0:
       return v8::Handle<v8::Value>();
     case 1:
-      return V8Proxy::ToV8Object(V8ClassIndex::NODE, namedItems.at(0).get());
+      return V8Proxy::NodeToV8Object(namedItems.at(0).get());
     default:
       NodeList* list = new V8VectorNodeList(namedItems);
       return V8Proxy::ToV8Object(V8ClassIndex::NODELIST,
                                  static_cast<Peerable*>(list));
   }
 }
 
 
 static v8::Handle<v8::Value> HTMLCollectionGetItem(
     HTMLCollection* collection, v8::Handle<v8::Value> argument) {
   v8::Local<v8::Uint32> index = argument->ToArrayIndex();
   if (index.IsEmpty()) {
     v8::Handle<v8::String> str = argument->ToString();
     v8::Handle<v8::Value> result =
       HTMLCollectionGetNamedItems(collection, ToWebCoreString(str));
     if (result.IsEmpty())
       return v8::Undefined();
     else
       return result;
   }
   unsigned i = index->Uint32Value();
   RefPtr<Node> result = collection->item(i);
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLCollection) {
   INC_STATS(L"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::FastToNativeObject<HTMLCollection>(
+  HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, info.Holder());
   String key = ToWebCoreString(name);
   return HTMLCollectionGetNamedItems(imp, key);
 }
 
 
 CALLBACK_FUNC_DECL(HTMLCollectionItem) {
   INC_STATS(L"DOM.HTMLCollection.item()");
-  HTMLCollection* imp = V8Proxy::FastToNativeObject<HTMLCollection>(
+  HTMLCollection* imp = V8Proxy::ToNativeObject<HTMLCollection>(
       V8ClassIndex::HTMLCOLLECTION, args.Holder());
   return HTMLCollectionGetItem(imp, args[0]);
 }
 
 
 CALLBACK_FUNC_DECL(HTMLCollectionNamedItem) {
   INC_STATS(L"DOM.HTMLCollection.namedItem()");
-  HTMLCollection* imp = V8Proxy::FastToNativeObject<HTMLCollection>(
+  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()");
   if (args.Length() < 1) return v8::Undefined();
 
-  HTMLCollection* imp = V8Proxy::FastToNativeObject<HTMLCollection>(
+  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
   // want.
   String name = ToWebCoreString(args[0]);
   v8::Local<v8::Uint32> index = args[1]->ToArrayIndex();
   if (index.IsEmpty()) return v8::Undefined();
   unsigned i = index->Uint32Value();
   Node* node = imp->namedItem(name);
   while (node) {
-    if (i == 0) return V8Proxy::ToV8Object(V8ClassIndex::NODE, node);
+    if (i == 0) return V8Proxy::NodeToV8Object(node);
     node = imp->nextNamedItem(name);
     i--;
   }
 
   return v8::Undefined();
 }
 
 
 static v8::Handle<v8::Value> V8HTMLSelectElementRemoveHelper(
     HTMLSelectElement* imp, const v8::Arguments& args) {
   if (V8HTMLOptionElement::HasInstance(args[0])) {
-    HTMLOptionElement* element = V8Proxy::ToNativeObject<HTMLOptionElement>(
-        V8ClassIndex::HTMLOPTIONELEMENT, args[0]);
+    HTMLOptionElement* element =
+        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");
-  HTMLSelectElement* imp = V8Proxy::FastToNativeObject<HTMLSelectElement>(
-      V8ClassIndex::HTMLSELECTELEMENT, args.Holder());
+  HTMLSelectElement* imp =
+      V8Proxy::DOMWrapperToNode<HTMLSelectElement>(args.Holder());
   return V8HTMLSelectElementRemoveHelper(imp, args);
 }
 
 CALLBACK_FUNC_DECL(HTMLOptionsCollectionRemove) {
   INC_STATS(L"DOM.HTMLOptionsCollection.remove()");
   HTMLOptionsCollection* imp =
-      V8Proxy::FastToNativeObject<HTMLOptionsCollection>(
+      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()");
   if (!V8HTMLOptionElement::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Undefined();
   }
   HTMLOptionsCollection* imp =
-      V8Proxy::FastToNativeObject<HTMLOptionsCollection>(
+      V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, args.Holder());
-  HTMLOptionElement* option = V8Proxy::ToNativeObject<HTMLOptionElement>(
-      V8ClassIndex::NODE, args[0]);
+  HTMLOptionElement* option =
+      V8Proxy::DOMWrapperToNode<HTMLOptionElement>(args[0]);
 
   ExceptionCode ec = 0;
   if (args.Length() < 2) {
     imp->add(option, ec);
   } else {
     bool ok;
     v8::TryCatch try_catch;
     int index = ToInt32(args[1], ok);
     if (try_catch.HasCaught()) {
       return v8::Undefined();
     }
     if (!ok) {
       ec = TYPE_MISMATCH_ERR;
     } else {
       imp->add(option, index, ec);
     }
   }
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowAddEventListener) {
   INC_STATS(L"DOM.DOMWindow.addEventListener()");
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(imp->frame(), true)) {
     return v8::Undefined();
   }
 
   if (!imp->frame())
     return v8::Undefined();  // DOMWindow could be disconnected from the frame
@@ skipping 15 matching lines @@
     bool useCapture = args[2]->BooleanValue();
     doc->addWindowEventListener(event_type, listener, useCapture);
   }
 
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowRemoveEventListener) {
   INC_STATS(L"DOM.DOMWindow.removeEventListener()");
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(imp->frame(), true)) {
     return v8::Undefined();
   }
 
   if (!imp->frame())
     return v8::Undefined();
@@ skipping 13 matching lines @@
     String event_type = ToWebCoreString(args[0]);
     bool useCapture = args[2]->BooleanValue();
     doc->removeWindowEventListener(event_type, listener, useCapture);
   }
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(DOMWindowPostMessage) {
   INC_STATS(L"DOM.DOMWindow.postMessage()");
-  DOMWindow* window = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   DOMWindow* source = V8Proxy::retrieveActiveFrame()->domWindow();
   ASSERT(source->frame());
 
   String domain = source->frame()->loader()->url().host();
   String uri = source->frame()->loader()->url().string();
 
   v8::TryCatch try_catch;
 
@@ skipping 121 matching lines @@
           user_gesture);
     }
   }
 
   return new_frame;
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowShowModalDialog) {
   INC_STATS(L"DOM.DOMWindow.showModalDialog()");
-  DOMWindow* window = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* window = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
   Frame* frame = window->frame();
 
   if (!frame)
     return v8::Undefined();
 
   if (!canShowModalDialogNow(frame) || !allowPopUp())
     return v8::Undefined();
 
   String url = valueToStringWithNullOrUndefinedCheck(args[0]);
@@ skipping 69 matching lines @@
   if (!return_value.IsEmpty()) {
     return return_value;
   }
 
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowOpen) {
   INC_STATS(L"DOM.DOMWindow.open()");
-  DOMWindow* parent = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* parent = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
   Frame* frame = parent->frame();
   if (!frame)
     return v8::Undefined();
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(frame, true)) {
     return v8::Undefined();
   }
@@ skipping 231 matching lines @@
     v8::Local<v8::Value> result = proxy->Evaluate(prop_name, 0, code, 0);
     return result;
   }
 
   // Search named items in the document.
   Document* doc = frame->document();
   if (doc) {
     RefPtr<HTMLCollection> items = doc->windowNamedItems(prop_name);
     if (items->length() >= 1) {
       if (items->length() == 1) {
-        return V8Proxy::ToV8Object(V8ClassIndex::NODE, items->firstItem());
+        return V8Proxy::NodeToV8Object(items->firstItem());
       } else {
         return V8Proxy::ToV8Object(V8ClassIndex::HTMLCOLLECTION,
                                    static_cast<Peerable*>(items.get()));
       }
     }
   }
 
   return v8::Handle<v8::Value>();
 }
 
@@ skipping 41 matching lines @@
            kHTMLDocumentInternalFieldCount);
     v8::Local<v8::Value> marker =
         info.Holder()->GetInternalField(kHTMLDocumentMarkerIndex);
     v8::Local<v8::Value> value =
         info.Holder()->GetInternalField(kHTMLDocumentShadowIndex);
     if (marker != value) {
       return value;
     }
   }
 
-  HTMLDocument* imp = V8Proxy::FastToNativeObject<HTMLDocument>(
-      V8ClassIndex::HTMLDOCUMENT, info.Holder());
+  HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(info.Holder());
 
   // Fast case for named elements that are not there.
   if (!imp->hasNamedItem(key) && !imp->hasDocExtraNamedItem(key)) {
     return v8::Handle<v8::Value>();
   }
 
 
   RefPtr<HTMLCollection> items = imp->documentNamedItems(key);
   if (items->length() == 0) return v8::Handle<v8::Value>();
   if (items->length() == 1) {
     Node* node = items->firstItem();
     Frame* frame = 0;
     if (node->hasTagName(HTMLNames::iframeTag) &&
         (frame = static_cast<HTMLIFrameElement*>(node)->contentFrame())) {
       return V8Proxy::ToV8Object(V8ClassIndex::DOMWINDOW, frame->domWindow());
     }
-    return V8Proxy::ToV8Object(V8ClassIndex::NODE, node);
+    return V8Proxy::NodeToV8Object(node);
   }
   return V8Proxy::ToV8Object(V8ClassIndex::HTMLCOLLECTION,
                              static_cast<Peerable*>(items.get()));
 }
 
 
 NAMED_PROPERTY_GETTER(HTMLFrameSetElement) {
   INC_STATS(L"DOM.HTMLFrameSetElement.NamedPropertyGetter");
-  HTMLFrameSetElement* imp = V8Proxy::FastToNativeObject<HTMLFrameSetElement>(
-      V8ClassIndex::HTMLFRAMESETELEMENT, info.Holder());
+  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");
-  HTMLFormElement* imp = V8Proxy::FastToNativeObject<HTMLFormElement>(
-      V8ClassIndex::HTMLFORMELEMENT, info.Holder());
+  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::ToV8Object(V8ClassIndex::NODE, elements.at(0).get());
+    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");
-  NamedNodeMap* imp = V8Proxy::FastToNativeObject<NamedNodeMap>(
+  NamedNodeMap* imp = V8Proxy::ToNativeObject<NamedNodeMap>(
       V8ClassIndex::NAMEDNODEMAP, info.Holder());
   RefPtr<Node> result = imp->item(index);
   if (!result) return v8::Handle<v8::Value>();
 
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 NAMED_PROPERTY_GETTER(NamedNodeMap) {
   INC_STATS(L"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::FastToNativeObject<NamedNodeMap>(
+  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::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 NAMED_PROPERTY_GETTER(NodeList) {
   INC_STATS(L"DOM.NodeList.NamedPropertyGetter");
-  NodeList* list = V8Proxy::FastToNativeObject<NodeList>(
+  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::ToV8Object(V8ClassIndex::NODE, result.get());
+    return V8Proxy::NodeToV8Object(result.get());
 
   return v8::Handle<v8::Value>();
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLFormElement) {
   INC_STATS(L"DOM.HTMLFormElement.IndexedPropertyGetter");
-  HTMLFormElement* form = V8Proxy::FastToNativeObject<HTMLFormElement>(
-      V8ClassIndex::HTMLFORMELEMENT, info.Holder());
+  HTMLFormElement* form =
+      V8Proxy::DOMWrapperToNode<HTMLFormElement>(info.Holder());
 
   RefPtr<Node> result = form->elements()->item(index);
   if (!result) return v8::Handle<v8::Value>();
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLOptionsCollection) {
   INC_STATS(L"DOM.HTMLOptionsCollection.IndexedPropertyGetter");
   HTMLOptionsCollection* collection =
-      V8Proxy::FastToNativeObject<HTMLOptionsCollection>(
+      V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, info.Holder());
 
   RefPtr<Node> result = collection->item(index);
   if (!result) return v8::Handle<v8::Value>();
 
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 static v8::Handle<v8::Value> OptionsCollectionSetter(uint32_t index,
     v8::Handle<v8::Value> value, HTMLSelectElement* base) {
   if (value->IsNull() || value->IsUndefined()) {
     base->remove(index);
     return value;
   }
 
   ExceptionCode ec = 0;
 
   // Check that the value is an HTMLOptionElement.  If not, throw a
   // TYPE_MISMATCH_ERR DOMException.
   if (!V8HTMLOptionElement::HasInstance(value)) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return value;
   }
 
-  HTMLOptionElement* element = V8Proxy::FastToNativeObject<HTMLOptionElement>(
-      V8ClassIndex::HTMLOPTIONELEMENT, v8::Handle<v8::Object>::Cast(value));
+  HTMLOptionElement* element =
+      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");
   HTMLOptionsCollection* collection =
-      V8Proxy::FastToNativeObject<HTMLOptionsCollection>(
+      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");
   HTMLSelectElement* select =
-      V8Proxy::FastToNativeObject<HTMLSelectElement>(
-          V8ClassIndex::HTMLSELECTELEMENT, info.Holder());
+      V8Proxy::DOMWrapperToNode<HTMLSelectElement>(info.Holder());
   return OptionsCollectionSetter(index, value, select);
 }
 
 
 // When getting properties on CSSStyleDeclarations, the name used from
 // Javascript and the actual name of the property are not the same, so
 // we have to do the following translation.  The translation turns upper
 // case characters into lower case characters and inserts dashes to
 // separate words.
 //
@@ skipping 39 matching lines @@
 
 NAMED_PROPERTY_GETTER(CSSStyleDeclaration) {
   INC_STATS(L"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::FastToNativeObject<CSSStyleDeclaration>(
+  CSSStyleDeclaration* imp = V8Proxy::ToNativeObject<CSSStyleDeclaration>(
       V8ClassIndex::CSSSTYLEDECLARATION, info.Holder());
 
   bool pixel_or_pos;
   String p = ToWebCoreString(name);
   String prop = CSSPropertyName(p, &pixel_or_pos);
 
   // Do not handle non-property names.
   if (!CSSStyleDeclaration::isPropertyName(prop)) {
     return v8::Handle<v8::Value>();
   }
@@ skipping 17 matching lines @@
   // 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");
-  CSSStyleDeclaration* imp = V8Proxy::FastToNativeObject<CSSStyleDeclaration>(
+  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");
-  HTMLPlugInElement* imp = V8Proxy::FastToNativeObject<HTMLPlugInElement>(
-      V8ClassIndex::NODE, info.Holder());
+  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");
-  HTMLPlugInElement* imp = V8Proxy::FastToNativeObject<HTMLPlugInElement>(
-      V8ClassIndex::NODE, info.Holder());
+  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()");
   return NPObjectInvokeDefaultHandler(args);
 }
 
 
 INDEXED_PROPERTY_GETTER(HTMLPlugInElement) {
   INC_STATS(L"DOM.HTMLPlugInElement.IndexedPropertyGetter");
-  HTMLPlugInElement* imp = V8Proxy::FastToNativeObject<HTMLPlugInElement>(
-      V8ClassIndex::NODE, info.Holder());
+  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");
-  HTMLPlugInElement* imp = V8Proxy::FastToNativeObject<HTMLPlugInElement>(
-      V8ClassIndex::NODE, info.Holder());
+  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");
   // Look for local properties first.
   if (info.Holder()->HasRealNamedProperty(name)) {
     return v8::Handle<v8::Value>();
   }
 
   // Search style sheet.
-  StyleSheetList* imp = V8Proxy::FastToNativeObject<StyleSheetList>(
+  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>();
 }
 
 
 CALLBACK_FUNC_DECL(CSSPrimitiveValueGetRGBColorValue) {
   INC_STATS(L"DOM.CSSPrimitiveValue.getRGBColorValue()");
-  CSSPrimitiveValue* value = V8Proxy::FastToNativeObject<CSSPrimitiveValue>(
+  CSSPrimitiveValue* value = V8Proxy::ToNativeObject<CSSPrimitiveValue>(
       V8ClassIndex::CSSPRIMITIVEVALUE, args.Holder());
   ExceptionCode ec = 0;
   unsigned int rgbcolor = value->getRGBColorValue(ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return V8Proxy::ToV8Object(V8ClassIndex::RGBCOLOR,
                              static_cast<Peerable*>(new RGBColor(rgbcolor)));
 }
 
 // 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()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      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]));
       }
       break;
     case 2:
@@ skipping 23 matching lines @@
                           "setStrokeColor: Invalid number of arguments");
       break;
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DSetFillColor) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.steFillColor()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      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]));
       }
       break;
     case 2:
@@ skipping 21 matching lines @@
                           "setFillColor: Invalid number of arguments");
       break;
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DStrokeRect) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.strokeRect()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
   ExceptionCode ec = 0;
   double x = 0, y = 0, width = 0, height = 0, line_width = 0;
   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]),
                         ec);
@@ skipping 11 matching lines @@
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DSetShadow) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.setShadow()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      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:
       if (args[3]->IsString())
         context->setShadow(TO_FLOAT(args[0]), TO_FLOAT(args[1]),
@@ skipping 30 matching lines @@
       break;
   }
 
     return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DDrawImage) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.drawImage()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      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::FastToNativeObject<HTMLImageElement>(
-            V8ClassIndex::HTMLIMAGEELEMENT, arg);
+        V8Proxy::DOMWrapperToNode<HTMLImageElement>(arg);
     switch (args.Length()) {
     case 3:
       context->drawImage(image_element, TO_FLOAT(args[1]), TO_FLOAT(args[2]));
       break;
     case 5:
       context->drawImage(image_element, TO_FLOAT(args[1]), TO_FLOAT(args[2]),
                          TO_FLOAT(args[3]), TO_FLOAT(args[4]), ec);
       if (ec != 0) {
         V8Proxy::SetDOMException(ec);
         return v8::Handle<v8::Value>();
@@ skipping 16 matching lines @@
                           "drawImage: Invalid number of arguments");
       return v8::Undefined();
     }
     return v8::Undefined();
   }
 
   // HTMLCanvasElement
   if (V8HTMLCanvasElement::HasInstance(arg)) {
     ExceptionCode ec = 0;
     HTMLCanvasElement* canvas_element =
-        V8Proxy::FastToNativeObject<HTMLCanvasElement>(
-            V8ClassIndex::HTMLCANVASELEMENT, arg);
+        V8Proxy::DOMWrapperToNode<HTMLCanvasElement>(arg);
     switch (args.Length()) {
     case 3:
       context->drawImage(canvas_element, TO_FLOAT(args[1]), TO_FLOAT(args[2]));
       break;
     case 5:
       context->drawImage(canvas_element, TO_FLOAT(args[1]), TO_FLOAT(args[2]),
                          TO_FLOAT(args[3]), TO_FLOAT(args[4]), ec);
       if (ec != 0) {
         V8Proxy::SetDOMException(ec);
         return v8::Handle<v8::Value>();
@@ skipping 20 matching lines @@
   }
 
   V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
   return v8::Handle<v8::Value>();
 }
 
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DDrawImageFromRect) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.drawImageFromRect()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   v8::Handle<v8::Value> arg = args[0];
 
-  if (!V8Proxy::MaybeDOMWrapper(arg)) {
-    V8Proxy::ThrowError(V8Proxy::TYPE_ERROR,
-                        "drawImageFromRect: Invalid type of arguments");
-    return v8::Undefined();
-  }
-
   if (V8HTMLImageElement::HasInstance(arg)) {
     HTMLImageElement* image_element =
-        V8Proxy::FastToNativeObject<HTMLImageElement>(
-            V8ClassIndex::HTMLIMAGEELEMENT, arg);
+        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();
 }
 
 // Remove the macro since we don't need it anymore.
 #undef TO_FLOAT
 
 CALLBACK_FUNC_DECL(CanvasRenderingContext2DCreatePattern) {
   INC_STATS(L"DOM.CanvasRenderingContext2D.createPattern()");
   CanvasRenderingContext2D* context =
-      V8Proxy::FastToNativeObject<CanvasRenderingContext2D>(
+      V8Proxy::ToNativeObject<CanvasRenderingContext2D>(
           V8ClassIndex::CANVASRENDERINGCONTEXT2D, args.Holder());
 
   v8::Handle<v8::Value> arg = args[0];
 
   if (V8HTMLImageElement::HasInstance(arg)) {
     HTMLImageElement* image_element =
-        V8Proxy::FastToNativeObject<HTMLImageElement>(
-            V8ClassIndex::HTMLIMAGEELEMENT, arg);
+        V8Proxy::DOMWrapperToNode<HTMLImageElement>(arg);
     ExceptionCode ec = 0;
     RefPtr<CanvasPattern> pattern =
         context->createPattern(image_element, ToWebCoreString(args[1]), ec);
     if (ec != 0) {
       V8Proxy::SetDOMException(ec);
       return v8::Handle<v8::Value>();
     }
     return V8Proxy::ToV8Object(V8ClassIndex::CANVASPATTERN,
                                static_cast<Peerable*>(pattern.get()));
   }
 
   if (V8HTMLCanvasElement::HasInstance(arg)) {
     HTMLCanvasElement* canvas_element =
-        V8Proxy::FastToNativeObject<HTMLCanvasElement>(
-            V8ClassIndex::HTMLCANVASELEMENT, arg);
+        V8Proxy::DOMWrapperToNode<HTMLCanvasElement>(arg);
     ExceptionCode ec = 0;
     RefPtr<CanvasPattern> pattern =
         context->createPattern(canvas_element, ToWebCoreString(args[1]), ec);
     if (ec != 0) {
       V8Proxy::SetDOMException(ec);
       return v8::Handle<v8::Value>();
     }
     return V8Proxy::ToV8Object(V8ClassIndex::CANVASPATTERN,
                                static_cast<Peerable*>(pattern.get()));
   }
 
   V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
   return v8::Handle<v8::Value>();
 }
 
 
 CALLBACK_FUNC_DECL(ClipboardClearData) {
   INC_STATS(L"DOM.Clipboard.clearData()");
-  Clipboard* imp = V8Proxy::FastToNativeObject<Clipboard>(
+  Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
   if (args.Length() == 0) {
     imp->clearAllData();
   } else {
     String v = ToWebCoreString(args[0]);
     imp->clearData(v);
   }
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(ClipboardGetData) {
   INC_STATS(L"DOM.Clipboard.getData()");
-  Clipboard* imp = V8Proxy::FastToNativeObject<Clipboard>(
+  Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
   if (args.Length() == 1) {
     bool success;
     String v = ToWebCoreString(args[0]);
     String result = imp->getData(v, success);
     if (success) return v8String(result);
     return v8::Undefined();
   }
 
   V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                      "getData: Invalid number of arguments");
 
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(ClipboardSetData) {
   INC_STATS(L"DOM.Clipboard.setData()");
-  Clipboard* imp = V8Proxy::FastToNativeObject<Clipboard>(
+  Clipboard* imp = V8Proxy::ToNativeObject<Clipboard>(
       V8ClassIndex::CLIPBOARD, args.Holder());
   if (args.Length() == 2) {
     String type = ToWebCoreString(args[0]);
     String data = ToWebCoreString(args[1]);
     bool result = imp->setData(type, data);
     return result?v8::True():v8::False();
   }
 
   V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR,
                      "setData: Invalid number of arguments");
@@ skipping 32 matching lines @@
     Node* contentDoc = frame->contentDocument();
     if (contentDoc && !V8Proxy::CheckNodeSecurity(contentDoc))
       return false;
   }
   return true;
 }
 
 
 CALLBACK_FUNC_DECL(ElementSetAttribute) {
   INC_STATS(L"DOM.Element.setAttribute()");
-  Element* imp = V8Proxy::FastToNativeObject<Element>(
-      V8ClassIndex::ELEMENT, args.Holder());
+  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()");
   if (!V8Attr::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Handle<v8::Value>();
   }
 
-  Attr* newAttr =
-      V8Proxy::FastToNativeObject<Attr>(V8ClassIndex::ATTR, args[0]);
-
+  Attr* newAttr = V8Proxy::DOMWrapperToNode<Attr>(args[0]);
+  Element* imp = V8Proxy::DOMWrapperToNode<Element>(args.Holder());
   ExceptionCode ec = 0;
-  Element* imp = V8Proxy::FastToNativeObject<Element>(
-      V8ClassIndex::ELEMENT, args.Holder());
 
   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::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 CALLBACK_FUNC_DECL(ElementSetAttributeNS) {
   INC_STATS(L"DOM.Element.setAttributeNS()");
-  Element* imp = V8Proxy::FastToNativeObject<Element>(
-      V8ClassIndex::ELEMENT, args.Holder());
+  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()");
   if (!V8Attr::HasInstance(args[0])) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Handle<v8::Value>();
   }
 
-  Attr* newAttr =
-      V8Proxy::FastToNativeObject<Attr>(V8ClassIndex::ATTR, args[0]);
-
-  Element* imp = V8Proxy::FastToNativeObject<Element>(
-      V8ClassIndex::ELEMENT, args.Holder());
+  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->setAttributeNodeNS(newAttr, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
+  return V8Proxy::NodeToV8Object(result.get());
 }
 
 
 ACCESSOR_SETTER(AttrValue) {
   Attr* imp =
-      V8Proxy::FastToNativeObject<Attr>(V8ClassIndex::ATTR, info.Holder());
+      V8Proxy::DOMWrapperToNode<Attr>(info.Holder());
   String v = valueToStringWithNullCheck(value);
   Element* ownerElement = imp->ownerElement();
 
   if (ownerElement &&
       !AllowSettingSrcToJavascriptURL(ownerElement, imp->name(), v))
     return;
 
   ExceptionCode ec = 0;
   imp->setValue(v, ec);
   V8Proxy::SetDOMException(ec);
 }
 
 
 ACCESSOR_SETTER(HTMLFrameElementSrc) {
-  HTMLFrameElement* imp = V8Proxy::FastToNativeObject<HTMLFrameElement>(
-      V8ClassIndex::HTMLFRAMEELEMENT, info.Holder());
+  HTMLFrameElement* imp =
+      V8Proxy::DOMWrapperToNode<HTMLFrameElement>(info.Holder());
   String v = valueToStringWithNullCheck(value);
 
   if (!AllowSettingFrameSrcToJavascriptUrl(imp, v)) return;
 
   imp->setSrc(v);
 }
 
 
 ACCESSOR_SETTER(HTMLFrameElementLocation) {
-  HTMLFrameElement* imp = V8Proxy::FastToNativeObject<HTMLFrameElement>(
-      V8ClassIndex::HTMLFRAMEELEMENT, info.Holder());
+  HTMLFrameElement* imp =
+      V8Proxy::DOMWrapperToNode<HTMLFrameElement>(info.Holder());
   String v = valueToStringWithNullCheck(value);
 
   if (!AllowSettingFrameSrcToJavascriptUrl(imp, v)) return;
 
   imp->setLocation(v);
 }
 
 
 ACCESSOR_SETTER(HTMLIFrameElementSrc) {
-  HTMLIFrameElement* imp = V8Proxy::FastToNativeObject<HTMLIFrameElement>(
-      V8ClassIndex::HTMLIFRAMEELEMENT, info.Holder());
+  HTMLIFrameElement* imp =
+      V8Proxy::DOMWrapperToNode<HTMLIFrameElement>(info.Holder());
   String v = valueToStringWithNullCheck(value);
 
   if (!AllowSettingFrameSrcToJavascriptUrl(imp, v)) return;
 
   imp->setSrc(v);
 }
 
 
 v8::Handle<v8::Value> V8Custom::WindowSetTimeoutImpl(const v8::Arguments& args,
                                                      bool single_shot) {
   int num_arguments = args.Length();
 
   if (num_arguments < 1) return v8::Undefined();
 
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(imp->frame(), true)) {
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> function = args[0];
 
@@ skipping 54 matching lines @@
   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()");
-  HTMLDocument* imp = V8Proxy::FastToNativeObject<HTMLDocument>(
-      V8ClassIndex::HTMLDOCUMENT, args.Holder());
+  HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(args.Holder());
   imp->write(WriteHelper_GetString(args));
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(HTMLDocumentWriteln) {
   INC_STATS(L"DOM.HTMLDocument.writeln()");
-  HTMLDocument* imp = V8Proxy::FastToNativeObject<HTMLDocument>(
-      V8ClassIndex::HTMLDOCUMENT, args.Holder());
+  HTMLDocument* imp = V8Proxy::DOMWrapperToNode<HTMLDocument>(args.Holder());
   imp->writeln(WriteHelper_GetString(args));
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(HTMLDocumentOpen) {
   INC_STATS(L"DOM.HTMLDocument.open()");
-  HTMLDocument* imp = V8Proxy::FastToNativeObject<HTMLDocument>(
-      V8ClassIndex::HTMLDOCUMENT, args.Holder());
+  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.
       v8::Local<v8::Value> function = global->Get(v8::String::New("open"));
@@ skipping 32 matching lines @@
   // Invoking HTMLDocument::clear() can cause a crash, since it
   // deletes the document's tokenizer while it may still be in use.
   // See b:1055485 for details.
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(DocumentEvaluate) {
   INC_STATS(L"DOM.Document.evaluate()");
 
-  Document* imp = V8Proxy::FastToNativeObject<Document>(
-      V8ClassIndex::DOCUMENT, args.Holder());
+  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::FastToNativeObject<Node>(V8ClassIndex::NODE, args[1]);
+    contextNode = V8Proxy::DOMWrapperToNode<Node>(args[1]);
   }
   // Find the XPath
   XPathNSResolver* resolver = NULL;
   if (V8XPathNSResolver::HasInstance(args[2])) {
-    resolver = V8Proxy::FastToNativeObject<XPathNSResolver>(
+    resolver = V8Proxy::ToNativeObject<XPathNSResolver>(
         V8ClassIndex::XPATHNSRESOLVER, args[2]);
   } else if (args[2]->IsObject()) {
     v8::Handle<v8::Object> obj = args[2]->ToObject();
     resolver = new JSXPathNSResolver(obj);
   } else if (!args[2]->IsNull() && !args[2]->IsUndefined()) {
     V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
     return v8::Handle<v8::Value>();
   }
   int type = ToInt32(args[3]);
   XPathResult* inResult = NULL;
   if (V8XPathResult::HasInstance(args[4])) {
-    inResult = V8Proxy::FastToNativeObject<XPathResult>(
+    inResult = V8Proxy::ToNativeObject<XPathResult>(
         V8ClassIndex::XPATHRESULT, args[4]);
   }
   RefPtr<XPathResult> result =
       imp->evaluate(expression, contextNode, resolver, type, inResult, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return V8Proxy::ToV8Object(V8ClassIndex::XPATHRESULT,
                              static_cast<Peerable*>(result.get()));
@@ skipping 29 matching lines @@
       return v8::Undefined();
     }
   }
 
   return v8String(String(out.data(), out.size()));
 }
 
 
 CALLBACK_FUNC_DECL(DOMWindowAtob) {
   INC_STATS(L"DOM.DOMWindow.atob()");
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(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()");
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, args.Holder());
 
   // Fast check This argument with the global object of security context.
   if ((args.This() != v8::Context::GetCurrentSecurityContext()->Global()) &&
       !V8Proxy::IsFromSameOrigin(imp->frame(), true)) {
     return v8::Undefined();
   }
 
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
@@ skipping 18 matching lines @@
 
 
 CALLBACK_FUNC_DECL(DOMWindowNOP) {
   INC_STATS(L"DOM.DOMWindow.nop()");
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(EventTargetNodeAddEventListener) {
   INC_STATS(L"DOM.EventTargetNode.addEventListener()");
-  EventTargetNode* node = V8Proxy::FastToNativeObject<EventTargetNode>(
-      V8ClassIndex::EVENTTARGETNODE, args.Holder());
+  EventTargetNode* node =
+      V8Proxy::DOMWrapperToNode<EventTargetNode>(args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(node->document()->frame());
   if (!proxy)
     return v8::Undefined();
 
   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()");
-  EventTargetNode* node = V8Proxy::FastToNativeObject<EventTargetNode>(
-      V8ClassIndex::EVENTTARGETNODE, args.Holder());
+  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();
 
   EventListener* listener =
     proxy->FindV8EventListener(args[1], false);
@@ skipping 41 matching lines @@
       return;
     }
   }
 
   // Should not reach here.
   ASSERT(false);
 }
 
 
 ACCESSOR_SETTER(XMLHttpRequestOnreadystatechange) {
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onreadystatechange()) {
       V8XHREventListener* listener =
           static_cast<V8XHREventListener*>(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->document()->frame());
     if (!proxy)
       return;
 
     EventListener* listener =
       proxy->FindOrCreateXHREventListener(value, false);
     if (listener) {
       imp->setOnreadystatechange(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 
 ACCESSOR_SETTER(XMLHttpRequestOnload) {
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, info.Holder());
   if (value->IsNull()) {
     if (imp->onload()) {
       V8XHREventListener* listener =
           static_cast<V8XHREventListener*>(imp->onload());
       v8::Local<v8::Object> v8_listener = listener->GetListenerObject();
       RemoveHiddenXHRDependency(info.Holder(), v8_listener);
     }
 
     imp->setOnload(0);
 
   } else {
     V8Proxy* proxy = V8Proxy::retrieve(imp->document()->frame());
     if (!proxy)
       return;
 
     EventListener* listener =
       proxy->FindOrCreateXHREventListener(value, false);
     if (listener) {
       imp->setOnload(listener);
       CreateHiddenXHRDependency(info.Holder(), value);
     }
   }
 }
 
 
 CALLBACK_FUNC_DECL(XMLHttpRequestAddEventListener) {
   INC_STATS(L"DOM.XMLHttpRequest.addEventListener()");
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(imp->document()->frame());
   if (!proxy)
     return v8::Undefined();
 
   EventListener* listener =
     proxy->FindOrCreateXHREventListener(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()");
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   V8Proxy* proxy = V8Proxy::retrieve(imp->document()->frame());
   if (!proxy)
     return v8::Undefined();  // probably leaked
 
   EventListener* listener =
     proxy->FindXHREventListener(args[1], false);
 
   if (listener) {
@@ skipping 15 matching lines @@
   // 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();
   }
 
   // get the implementation
-  XMLHttpRequest* xhr = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* xhr = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   // retrieve parameters
   String method = ToWebCoreString(args[0]);
   String urlstring = ToWebCoreString(args[1]);
   V8Proxy* proxy = V8Proxy::retrieve();
   KURL url =
     proxy->frame()->document()->completeURL(urlstring).deprecatedString();
 
   bool async = (args.Length() < 3) ? true : args[2]->BooleanValue();
@@ skipping 28 matching lines @@
 }
 
 
 CALLBACK_FUNC_DECL(XMLHttpRequestSend) {
   INC_STATS(L"DOM.XMLHttpRequest.send()");
   // Two cases:
   // send(document)
   // send(string)
 
   // get implementation
-  XMLHttpRequest* xhr = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* xhr = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
 
   String body;
   if (args.Length() >= 1) {
     v8::Handle<v8::Value> arg = args[0];
     if (IsDocumentType(arg)) {
       v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(arg);
-      Document* doc =
-          V8Proxy::ToNativeObject<Document>(V8ClassIndex::DOCUMENT, obj);
+      Document* doc = V8Proxy::DOMWrapperToNode<Document>(obj);
       ASSERT(doc);
       body = doc->toString();
     } else {
       body = valueToStringWithNullCheck(arg);
     }
   }
 
   ExceptionCode ec = 0;
   xhr->send(body, ec);
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
 
   return v8::Undefined();
 }
 
 
 CALLBACK_FUNC_DECL(XMLHttpRequestSetRequestHeader) {
   INC_STATS(L"DOM.XMLHttpRequest.setRequestHeader()");
   if (args.Length() < 2) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  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()");
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  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()");
   if (args.Length() < 1) {
     V8Proxy::ThrowError(V8Proxy::SYNTAX_ERROR, "Not enough arguments");
     return v8::Undefined();
   }
 
-  XMLHttpRequest* imp = V8Proxy::FastToNativeObject<XMLHttpRequest>(
+  XMLHttpRequest* imp = V8Proxy::ToNativeObject<XMLHttpRequest>(
       V8ClassIndex::XMLHTTPREQUEST, args.Holder());
   String value = ToWebCoreString(args[0]);
   imp->overrideMIMEType(value);
   return v8::Undefined();
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerParentNode) {
   INC_STATS(L"DOM.TreeWalker.parentNode()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->parentNode());
+  return V8Proxy::NodeToV8Object(imp->parentNode());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerFirstChild) {
   INC_STATS(L"DOM.TreeWalker.firstChild()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->firstChild());
+  return V8Proxy::NodeToV8Object(imp->firstChild());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerLastChild) {
   INC_STATS(L"DOM.TreeWalker.lastChild()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->lastChild());
+  return V8Proxy::NodeToV8Object(imp->lastChild());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextNode) {
   INC_STATS(L"DOM.TreeWalker.nextNode()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->nextNode());
+  return V8Proxy::NodeToV8Object(imp->nextNode());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousNode) {
   INC_STATS(L"DOM.TreeWalker.previousNode()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->previousNode());
+  return V8Proxy::NodeToV8Object(imp->previousNode());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextSibling) {
   INC_STATS(L"DOM.TreeWalker.nextSibling()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->nextSibling());
+  return V8Proxy::NodeToV8Object(imp->nextSibling());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousSibling) {
   INC_STATS(L"DOM.TreeWalker.previousSibling()");
-  TreeWalker* imp = V8Proxy::FastToNativeObject<TreeWalker>(
+  TreeWalker* imp = V8Proxy::ToNativeObject<TreeWalker>(
       V8ClassIndex::TREEWALKER, args.Holder());
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->previousSibling());
+  return V8Proxy::NodeToV8Object(imp->previousSibling());
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorNextNode) {
   INC_STATS(L"DOM.NodeIterator.nextNode()");
-  NodeIterator* imp = V8Proxy::FastToNativeObject<NodeIterator>(
+  NodeIterator* imp = V8Proxy::ToNativeObject<NodeIterator>(
       V8ClassIndex::NODEITERATOR, args.Holder());
   ExceptionCode ec = 0;
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->nextNode(ec));
+  return V8Proxy::NodeToV8Object(imp->nextNode(ec));
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorPreviousNode) {
   INC_STATS(L"DOM.NodeIterator.previousNode()");
-  NodeIterator* imp = V8Proxy::FastToNativeObject<NodeIterator>(
+  NodeIterator* imp = V8Proxy::ToNativeObject<NodeIterator>(
       V8ClassIndex::NODEITERATOR, args.Holder());
   ExceptionCode ec = 0;
-  return V8Proxy::ToV8Object(V8ClassIndex::NODE, imp->previousNode(ec));
+  return V8Proxy::NodeToV8Object(imp->previousNode(ec));
 }
 
 CALLBACK_FUNC_DECL(NodeFilterAcceptNode) {
   INC_STATS(L"DOM.NodeFilter.acceptNode()");
-  NodeFilter* imp = V8Proxy::FastToNativeObject<NodeFilter>(
+  NodeFilter* imp = V8Proxy::ToNativeObject<NodeFilter>(
       V8ClassIndex::NODEFILTER, args.Holder());
-  Node* node = V8Proxy::FastToNativeObject<Node>(V8ClassIndex::NODE, args[0]);
+  Node* node = V8Proxy::DOMWrapperToNode<Node>(args[0]);
   return v8::Local<v8::Integer>(v8::Integer::New(imp->acceptNode(node)));
 }
 
 ACCESSOR_SETTER(DOMWindowEventHandler) {
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return;
 
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, holder);
   if (!imp->frame())
     return;
 
   Document* doc = imp->frame()->document();
   if (!doc)
     return;
 
   // Name starts with 'on', remove them.
   String key = ToWebCoreString(name);
@@ skipping 16 matching lines @@
   }
 }
 
 
 ACCESSOR_GETTER(DOMWindowEventHandler) {
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return v8::Undefined();
 
-  DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
+  DOMWindow* imp = V8Proxy::ToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, holder);
   if (!imp->frame())
     return v8::Undefined();
 
   Document* doc = imp->frame()->document();
   if (!doc)
     return v8::Undefined();
 
   // Name starts with 'on', remove them.
   String key = ToWebCoreString(name);
   ASSERT(key.startsWith("on"));
   String event_type = key.substring(2);
 
   EventListener* listener = doc->getHTMLWindowEventListener(event_type);
   return V8Proxy::EventListenerToV8Object(listener);
 }
 
 
 ACCESSOR_SETTER(ElementEventHandler) {
-  EventTargetNode* node = V8Proxy::FastToNativeObject<EventTargetNode>(
-    V8ClassIndex::EVENTTARGETNODE, info.Holder());
+  EventTargetNode* node =
+      V8Proxy::DOMWrapperToNode<EventTargetNode>(info.Holder());
 
   // Name starts with 'on', remove them.
   String key = ToWebCoreString(name);
   ASSERT(key.startsWith("on"));
   String event_type = key.substring(2);
 
   // Set handler if the value is a function.  Otherwise, clear the
   // event handler.
   if (value->IsFunction()) {
     V8Proxy* proxy = V8Proxy::retrieve(node->document()->frame());
     // the document might be created using createDocument,
     // which does not have a frame, use the active frame
     if (!proxy)
       proxy = V8Proxy::retrieve(V8Proxy::retrieveActiveFrame());
     if (!proxy)
       return;
 
     EventListener* listener =
       proxy->FindOrCreateV8EventListener(value, true);
     if (listener) {
       node->setHTMLEventListener(event_type, listener);
     }
   } else {
     node->removeHTMLEventListener(event_type);
   }
 }
 
 
 ACCESSOR_GETTER(ElementEventHandler) {
-  EventTargetNode* node = V8Proxy::FastToNativeObject<EventTargetNode>(
-      V8ClassIndex::EVENTTARGETNODE, info.Holder());
+  EventTargetNode* node =
+      V8Proxy::DOMWrapperToNode<EventTargetNode>(info.Holder());
 
   // Name starts with 'on', remove them.
   String key = ToWebCoreString(name);
   ASSERT(key.startsWith("on"));
   String event_type = key.substring(2);
 
   EventListener* listener = node->getHTMLEventListener(event_type);
   return V8Proxy::EventListenerToV8Object(listener);
 }
 
 
 ACCESSOR_SETTER(HTMLOptionsCollectionLength) {
   HTMLOptionsCollection* imp =
-      V8Proxy::FastToNativeObject<HTMLOptionsCollection>(
+      V8Proxy::ToNativeObject<HTMLOptionsCollection>(
           V8ClassIndex::HTMLOPTIONSCOLLECTION, info.Holder());
   double v = value->NumberValue();
   unsigned newLength = 0;
   ExceptionCode ec = 0;
   if (!isnan(v) && !isinf(v)) {
     if (v < 0.0) {
       ec = INDEX_SIZE_ERR;
     } else if (v > static_cast<double>(UINT_MAX)) {
       newLength = UINT_MAX;
     } else {
       newLength = static_cast<unsigned>(v);
     }
   }
   if (!ec) imp->setLength(value->Uint32Value(), ec);
   V8Proxy::SetDOMException(ec);
 }
 
 #if ENABLE(SVG)
 CALLBACK_FUNC_DECL(SVGMatrixInverse) {
   INC_STATS(L"DOM.SVGMatrix.inverse()");
   AffineTransform imp =
-      *V8Proxy::FastToNativeObject<V8SVGPODTypeWrapper<AffineTransform> >(
+      *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 V8SVGPODTypeWrapperCreatorReadOnly<AffineTransform>(result));
   return V8Proxy::ToV8Object(V8ClassIndex::SVGMATRIX, peer);
 }
 
 CALLBACK_FUNC_DECL(SVGMatrixRotateFromVector) {
   INC_STATS(L"DOM.SVGMatrix.rotateFromVector()");
   AffineTransform imp =
-      *V8Proxy::FastToNativeObject<V8SVGPODTypeWrapper<AffineTransform> >(
+      *V8Proxy::ToNativeObject<V8SVGPODTypeWrapper<AffineTransform> >(
           V8ClassIndex::SVGMATRIX, args.Holder());
   ExceptionCode ec = 0;
   float x = static_cast<float>(args[0]->NumberValue());
   float y = static_cast<float>(args[1]->NumberValue());
   AffineTransform result = imp;
   result.rotateFromVector(x, y);
   if (x == 0.0 || y == 0.0) {
     ec = SVGException::SVG_INVALID_VALUE_ERR;
   }
   if (ec != 0) {
@@ skipping 54 matching lines @@
   }
 
   return V8Proxy::CanAccess(target);
 }
 
 
 INDEXED_ACCESS_CHECK(History) {
   ASSERT(V8ClassIndex::ToWrapperType(data) == V8ClassIndex::HISTORY);
   // Only allow same origin access
   History* imp =
-      V8Proxy::FastToNativeObject<History>(V8ClassIndex::HISTORY, host);
+      V8Proxy::ToNativeObject<History>(V8ClassIndex::HISTORY, host);
   return V8Proxy::IsFromSameOrigin(imp->frame(), false);
 }
 
 
 NAMED_ACCESS_CHECK(History) {
   ASSERT(V8ClassIndex::ToWrapperType(data) == V8ClassIndex::HISTORY);
   // Only allow same origin access
   History* imp =
-      V8Proxy::FastToNativeObject<History>(V8ClassIndex::HISTORY, host);
+      V8Proxy::ToNativeObject<History>(V8ClassIndex::HISTORY, host);
   return V8Proxy::IsFromSameOrigin(imp->frame(), false);
 }
 
 
 INDEXED_ACCESS_CHECK(Location) {
   ASSERT(V8ClassIndex::ToWrapperType(data) == V8ClassIndex::LOCATION);
   // Only allow same origin access
   Location* imp =
-      V8Proxy::FastToNativeObject<Location>(V8ClassIndex::LOCATION, host);
+      V8Proxy::ToNativeObject<Location>(V8ClassIndex::LOCATION, host);
   return V8Proxy::IsFromSameOrigin(imp->frame(), false);
 }
 
 
 NAMED_ACCESS_CHECK(Location) {
   ASSERT(V8ClassIndex::ToWrapperType(data) == V8ClassIndex::LOCATION);
   // Only allow same origin access
   Location* imp =
-      V8Proxy::FastToNativeObject<Location>(V8ClassIndex::LOCATION, host);
+      V8Proxy::ToNativeObject<Location>(V8ClassIndex::LOCATION, host);
   return V8Proxy::IsFromSameOrigin(imp->frame(), false);
 }
 
 
 #undef INDEXED_ACCESS_CHECK
 #undef NAMED_ACCESS_CHECK
 #undef ACCESSOR_GETTER
 #undef ACCESSOR_SETTER
 #undef CALLBACK_FUNC_DECL
 #undef NAMED_PROPERTY_GETTER
 #undef NAMED_PROPERTY_SETTER
 #undef INDEXED_PROPERTY_GETTER
 #undef INDEXED_PROPERTY_SETTER
 
 
 // static
 Frame* V8Custom::GetTargetFrame(v8::Local<v8::Object> host,
                                 v8::Local<v8::Value> data) {
   Frame* target = 0;
   switch (V8ClassIndex::ToWrapperType(data)) {
     case V8ClassIndex::DOMWINDOW: {
       v8::Handle<v8::Value> window = host->GetPrototype();
       DOMWindow* target_win =
         V8Proxy::ToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, window);
       target = target_win->frame();
       break;
     }
     case V8ClassIndex::LOCATION: {
       History* imp =
-          V8Proxy::FastToNativeObject<History>(V8ClassIndex::HISTORY, host);
+          V8Proxy::ToNativeObject<History>(V8ClassIndex::HISTORY, host);
       target = imp->frame();
       break;
     }
     case V8ClassIndex::HISTORY: {
       Location* imp =
-          V8Proxy::FastToNativeObject<Location>(V8ClassIndex::LOCATION, host);
+          V8Proxy::ToNativeObject<Location>(V8ClassIndex::LOCATION, host);
       target = imp->frame();
       break;
     }
   }
   return target;
 }
 
 #if ENABLE(SVG)
 V8ClassIndex::V8WrapperType V8Custom::DowncastSVGPathSeg(void* path_seg) {
   WebCore::SVGPathSeg *real_path_seg =
@@ skipping 29 matching lines @@
 #undef MAKE_CASE
 
   default:
     return V8ClassIndex::INVALID_CLASS_INDEX;
   }
 }
 
 #endif  // ENABLE(SVG)
 
 }  // namespace WebCore