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

webkit/port/bindings/v8/v8_proxy.cpp

 // Copyright (c) 2008, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 273 matching lines @@
 
 static void WeakSVGElementInstanceCallback(v8::Persistent<v8::Object> obj,
                                            void* param) {
   SVGElementInstance* instance = static_cast<SVGElementInstance*>(param);
   ASSERT(dom_svg_element_instance_map().contains(instance));
 
   instance->deref();
   dom_svg_element_instance_map().forget(instance);
 }
 
-v8::Handle<v8::Object> V8Proxy::SVGElementInstanceToV8Object(
+v8::Handle<v8::Value> V8Proxy::SVGElementInstanceToV8Object(
     SVGElementInstance* instance) {
-  if (!instance) return v8::Handle<v8::Object>();
+  if (!instance) return v8::Null();
 
   v8::Handle<v8::Object> existing_instance =
       dom_svg_element_instance_map().get(instance);
   if (!existing_instance.IsEmpty()) {
     return existing_instance;
   }
 
   instance->ref();
 
   // Instantiate the V8 object and remember it
   v8::Handle<v8::Object> result =
-      InstantiateV8Object(V8ClassIndex::SVGELEMENTINSTANCE, instance);
+      InstantiateV8Object(V8ClassIndex::SVGELEMENTINSTANCE,
+                          V8ClassIndex::SVGELEMENTINSTANCE,
+                          instance);
   if (!result.IsEmpty()) {
     // Only update the DOM SVG element map if the result is non-empty.
     dom_svg_element_instance_map().set(instance,
       v8::Persistent<v8::Object>::New(result));
   }
   return result;
 }
 
 // SVG non-node elements may have a reference to a context node which
 // should be notified when the element is changed
 static void WeakSVGObjectWithContext(v8::Persistent<v8::Object> obj,
                                      void* param);
 
 // Map of SVG objects with contexts to V8 objects
 static DOMWrapperMap<Peerable>& dom_svg_object_with_context_map() {
   static DOMPeerableWrapperMap<Peerable>
     static_dom_svg_object_with_context_map(&WeakSVGObjectWithContext);
   return static_dom_svg_object_with_context_map;
 }
 
 // Map of SVG objects with contexts to their contexts
 static HashMap<void*, SVGElement*>& svg_object_to_context_map() {
   static HashMap<void*, SVGElement*> static_svg_object_to_context_map;
   return static_svg_object_to_context_map;
 }
 
-v8::Handle<v8::Object> V8Proxy::SVGObjectWithContextToV8Object(
+v8::Handle<v8::Value> V8Proxy::SVGObjectWithContextToV8Object(
   Peerable* object, V8ClassIndex::V8WrapperType type) {
-  if (!object) return v8::Handle<v8::Object>();
+  if (!object) return v8::Null();
 
   // Special case: SVGPathSegs need to be downcast to their real type
   if (type == V8ClassIndex::SVGPATHSEG) {
     type = V8Custom::DowncastSVGPathSeg(object);
   }
 
   v8::Persistent<v8::Object> result =
     dom_svg_object_with_context_map().get(object);
   if (result.IsEmpty()) {
-    v8::Local<v8::Object> v8obj = InstantiateV8Object(type, object);
+    v8::Local<v8::Object> v8obj = InstantiateV8Object(type, type, object);
     if (!v8obj.IsEmpty()) {
       result = v8::Persistent<v8::Object>::New(v8obj);
       dom_svg_object_with_context_map().set(object, result);
     }
   }
 
   return result;
 }
 
 static void WeakSVGObjectWithContext(v8::Persistent<v8::Object> obj,
@@ skipping 743 matching lines @@
     case V8ClassIndex::HTMLOPTIONSCOLLECTION:
       SetCollectionNamedGetter<HTMLOptionsCollection>(desc, V8ClassIndex::NODE);
       desc->InstanceTemplate()->SetIndexedPropertyHandler(
           USE_INDEXED_PROPERTY_GETTER(HTMLOptionsCollection),
           USE_INDEXED_PROPERTY_SETTER(HTMLOptionsCollection));
       desc->InstanceTemplate()->SetCallAsFunctionHandler(
           USE_CALLBACK(HTMLCollectionCallAsFunction));
       break;
     case V8ClassIndex::HTMLSELECTELEMENT:
       desc->InstanceTemplate()->SetNamedPropertyHandler(
-          CollectionNamedPropertyGetter<HTMLSelectElement>,
+          NodeCollectionNamedPropertyGetter<HTMLSelectElement>,
           0,
           0,
           0,
           0,
           v8::External::New(reinterpret_cast<void*>(V8ClassIndex::NODE)));
       desc->InstanceTemplate()->SetIndexedPropertyHandler(
-          CollectionIndexedPropertyGetter<HTMLSelectElement>,
+          NodeCollectionIndexedPropertyGetter<HTMLSelectElement>,
           USE_INDEXED_PROPERTY_SETTER(HTMLSelectElementCollection),
           0,
           0,
-          CollectionIndexedPropertyEnumerator<HTMLSelectElement>,
+          NodeCollectionIndexedPropertyEnumerator<HTMLSelectElement>,
           v8::External::New(reinterpret_cast<void*>(V8ClassIndex::NODE)));
       break;
     case V8ClassIndex::HTMLDOCUMENT: {
       desc->InstanceTemplate()->SetNamedPropertyHandler(
           USE_NAMED_PROPERTY_GETTER(HTMLDocument),
           USE_NAMED_PROPERTY_SETTER(HTMLDocument),
           0,
           USE_NAMED_PROPERTY_DELETER(HTMLDocument));
 
       // We add an extra internal field to all Document wrappers for
@@ skipping 45 matching lines @@
           USE_NAMED_PROPERTY_GETTER(HTMLFrameSetElement));
       break;
     case V8ClassIndex::HTMLFORMELEMENT:
       desc->InstanceTemplate()->SetNamedPropertyHandler(
           USE_NAMED_PROPERTY_GETTER(HTMLFormElement));
       desc->InstanceTemplate()->SetIndexedPropertyHandler(
           USE_INDEXED_PROPERTY_GETTER(HTMLFormElement),
           0,
           0,
           0,
-          CollectionIndexedPropertyEnumerator<HTMLFormElement>,
+          NodeCollectionIndexedPropertyEnumerator<HTMLFormElement>,
           v8::External::New(reinterpret_cast<void*>(V8ClassIndex::NODE)));
       break;
     case V8ClassIndex::STYLESHEET:  // fall through
     case V8ClassIndex::CSSSTYLESHEET: {
       // We add an extra internal field to hold a reference to
       // the owner node. 
       v8::Local<v8::ObjectTemplate> instance_template =
         desc->InstanceTemplate();
       ASSERT(instance_template->InternalFieldCount() ==
              V8Custom::kDefaultWrapperInternalFieldCount);
@@ skipping 602 matching lines @@
   return v8::Context::GetCurrent();
 }
 
 
 v8::Handle<v8::Value> V8Proxy::ToV8Object(V8ClassIndex::V8WrapperType type,
                                           void* imp) {
   ASSERT(type != V8ClassIndex::EVENTLISTENER);
   ASSERT(type != V8ClassIndex::EVENTTARGET);
   ASSERT(type != V8ClassIndex::EVENT);
 
-  if (!imp) return v8::Null();
-
 #define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE:
 
   switch (type) {
     NODE_WRAPPER_TYPES(MAKE_CASE)
     HTMLELEMENT_TYPES(MAKE_CASE)
 #if ENABLE(SVG)
     SVGNODE_WRAPPER_TYPES(MAKE_CASE)
     SVGELEMENT_TYPES(MAKE_CASE)
 #endif
       return NodeToV8Object(static_cast<Node*>(imp));
@@ skipping 14 matching lines @@
         return SVGObjectWithContextToV8Object(static_cast<Peerable*>(imp),
                                               type);
       }
 #endif
     default:
       break;
   }
 
 #undef MAKE_CASE
 
+  if (!imp) return v8::Null();
+
   // Non DOM node
   Peerable* obj = static_cast<Peerable*>(imp);
   v8::Persistent<v8::Object> result = dom_object_map().get(obj);
   if (result.IsEmpty()) {
-    v8::Local<v8::Object> v8obj = InstantiateV8Object(type, imp);
+    v8::Local<v8::Object> v8obj = InstantiateV8Object(type, type, imp);
     if (!v8obj.IsEmpty()) {
       result = v8::Persistent<v8::Object>::New(v8obj);
       dom_object_map().set(obj, result);
 
       // Special case for Location and Navigator. Both Safari and FF let
       // Location and Navigator JS wrappers survive GC. To mimic their
       // behaviors, V8 creates hidden references from the DOMWindow to
       // location and navigator objects. These references get cleared
       // when the DOMWindow is reused by a new page.
       if (type == V8ClassIndex::LOCATION) {
@@ skipping 23 matching lines @@
   ASSERT(!global.IsEmpty());
   // Look for real DOM wrapper.
   global = LookupDOMWrapper(V8ClassIndex::DOMWINDOW, global);
   ASSERT(global->GetInternalField(internal_index)->IsUndefined());
   global->SetInternalField(internal_index, jsobj);
 }
 
 
 V8ClassIndex::V8WrapperType V8Proxy::GetDOMWrapperType(
     v8::Handle<v8::Object> object) {
-  if (!MaybeDOMWrapper(object)) {
-    return V8ClassIndex::INVALID_CLASS_INDEX;
-  }
+  ASSERT(MaybeDOMWrapper(object));
 
-  v8::Handle<v8::Value> type = object->GetInternalField(1);
+  v8::Handle<v8::Value> type =
+      object->GetInternalField(V8Custom::kDOMWrapperTypeIndex);
   return V8ClassIndex::FromInt(type->Int32Value());
 }
 
 
-void* V8Proxy::FastToNativeObjectImpl(V8ClassIndex::V8WrapperType type,
-                                      v8::Handle<v8::Value> object) {
+void* V8Proxy::ToNativeObjectImpl(V8ClassIndex::V8WrapperType type,
+                                  v8::Handle<v8::Value> object) {
   // Native event listener is per frame, it cannot be handled
   // by this generic function.
   ASSERT(type != V8ClassIndex::EVENTLISTENER);
   ASSERT(type != V8ClassIndex::EVENTTARGET);
 
   ASSERT(MaybeDOMWrapper(object));
 
+  switch (type) {
 #define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE:
-  switch (type) {
     NODE_WRAPPER_TYPES(MAKE_CASE)

[Mike Belshe, 2008/09/23 00:36:13]

I wonder if we shouldn't #ifndef NDEBUG these to avoid having a large switch
statement here

[Feng Qian, 2008/09/23 21:46:04]

Here I'd like to let it return NULL so the render will crash right after this
call. This shouldn't happen although.

I looked at the generated assembly, a jump table is used for the big switch
statement. So the runtime overhead isn't high.

On 2008/09/23 00:36:13, mbelshe wrote:

     HTMLELEMENT_TYPES(MAKE_CASE)
 #if ENABLE(SVG)
     SVGNODE_WRAPPER_TYPES(MAKE_CASE)
     SVGELEMENT_TYPES(MAKE_CASE)
 #endif
-      return FastDOMWrapperToNative<Node>(object);
+      ASSERT(false);
+      return NULL;
     case V8ClassIndex::XMLHTTPREQUEST:
-      return FastDOMWrapperToNative<XMLHttpRequest>(object);
+      return DOMWrapperToNative<XMLHttpRequest>(object);
     case V8ClassIndex::EVENT:
-      return FastDOMWrapperToNative<Event>(object);
+      return DOMWrapperToNative<Event>(object);
     case V8ClassIndex::CSSRULE:
-      return FastDOMWrapperToNative<CSSRule>(object);
+      return DOMWrapperToNative<CSSRule>(object);
     default:
       break;
   }
 #undef MAKE_CASE
 
-  return FastDOMWrapperToNative<Peerable>(object);
+  return DOMWrapperToNative<Peerable>(object);
 }
 
 
 v8::Handle<v8::Object> V8Proxy::LookupDOMWrapper(
     V8ClassIndex::V8WrapperType type, v8::Handle<v8::Value> value) {
   if (value.IsEmpty()) return v8::Handle<v8::Object>();
 
   v8::Handle<v8::FunctionTemplate> desc = V8Proxy::GetTemplate(type);
   while (value->IsObject()) {
     v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
     if (desc->HasInstance(object))
       return object;
 
     value = object->GetPrototype();
   }
   return v8::Handle<v8::Object>();
 }
 
 
-void* V8Proxy::ToNativeObjectImpl(V8ClassIndex::V8WrapperType type,
-                                  v8::Handle<v8::Value> object) {
-  // Native event listener is per frame, it cannot be handled
-  // by this generic function.
-  ASSERT(type != V8ClassIndex::EVENTLISTENER);
-  ASSERT(type != V8ClassIndex::EVENTTARGET);
-
-  // It could be null, undefined, etc.
-  if (!MaybeDOMWrapper(object))
-    return 0;
-
-#define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE:
-  switch (type) {
-    NODE_WRAPPER_TYPES(MAKE_CASE)
-    HTMLELEMENT_TYPES(MAKE_CASE)
-#if ENABLE(SVG)
-    SVGNODE_WRAPPER_TYPES(MAKE_CASE)
-    SVGELEMENT_TYPES(MAKE_CASE)
-#endif
-      return DOMWrapperToNative<Node>(object);
-    case V8ClassIndex::XMLHTTPREQUEST:
-      return DOMWrapperToNative<XMLHttpRequest>(object);
-    case V8ClassIndex::EVENT:
-      return DOMWrapperToNative<Event>(object);
-    case V8ClassIndex::CSSRULE:
-      return DOMWrapperToNative<CSSRule>(object);
-    default:
-      break;
-  }
-#undef MAKE_CASE
-
-  return DOMWrapperToNative<Peerable>(object);
-}
-
-
 NodeFilter* V8Proxy::ToNativeNodeFilter(v8::Handle<v8::Value> filter) {
   // A NodeFilter is used when walking through a DOM tree or iterating tree
   // nodes.
   // TODO: we may want to cache NodeFilterCondition and NodeFilter
   // object, but it is minor.
   // NodeFilter is passed to NodeIterator that has a ref counted pointer
   // to NodeFilter. NodeFilter has a ref counted pointer to NodeFilterCondition.
   // In NodeFilterCondition, filter object is persisted in its constructor,
   // and disposed in its destructor. No need to use peer field in this case.
   if (!filter->IsFunction()) return 0;
 
   NodeFilterCondition* cond = new V8NodeFilterCondition(filter);
   return new NodeFilter(cond);
 }
 
 
 v8::Local<v8::Object> V8Proxy::InstantiateV8Object(
-    V8ClassIndex::V8WrapperType type, void* imp) {
-  V8ClassIndex::V8WrapperType wrapper_type = type;
+    V8ClassIndex::V8WrapperType desc_type,
+    V8ClassIndex::V8WrapperType cptr_type,
+    void* imp) {
   // Make a special case for document.all
-  if (type == V8ClassIndex::HTMLCOLLECTION &&
+  if (desc_type == V8ClassIndex::HTMLCOLLECTION &&
       static_cast<HTMLCollection*>(imp)->type() == HTMLCollection::DocAll) {
-    wrapper_type = V8ClassIndex::UNDETECTABLEHTMLCOLLECTION;
+    desc_type = V8ClassIndex::UNDETECTABLEHTMLCOLLECTION;
   }
 
   // Special case for HTMLInputElements that support selection.
-  if (type == V8ClassIndex::HTMLINPUTELEMENT) {
+  if (desc_type == V8ClassIndex::HTMLINPUTELEMENT) {
     HTMLInputElement* element = static_cast<HTMLInputElement*>(imp);
     if (element->canHaveSelection()) {
-      wrapper_type = V8ClassIndex::HTMLSELECTIONINPUTELEMENT;
+      desc_type = V8ClassIndex::HTMLSELECTIONINPUTELEMENT;
     }
   }
 
-  v8::Persistent<v8::FunctionTemplate> desc = GetTemplate(wrapper_type);
+  v8::Persistent<v8::FunctionTemplate> desc = GetTemplate(desc_type);
   v8::Local<v8::Function> function = desc->GetFunction();
   v8::Local<v8::Object> instance = SafeAllocation::NewInstance(function);
   if (!instance.IsEmpty()) {
     // Avoid setting the DOM wrapper for failed allocations.
-    SetDOMWrapper(instance, V8ClassIndex::ToInt(type), imp);
+    SetDOMWrapper(instance, V8ClassIndex::ToInt(cptr_type), imp);
   }
   return instance;
 }
 
 v8::Handle<v8::Value> V8Proxy::CheckNewLegal(const v8::Arguments& args) {
   if (!AllowAllocation::m_current) {
     return ThrowError(TYPE_ERROR, "Illegal constructor");
   } else {
     return args.This();
   }
 }
 
 
 v8::Handle<v8::Value> V8Proxy::WrapCPointer(void* cptr) {
   // Represent void* as int
   int addr = reinterpret_cast<int>(cptr);
-  if ((addr & 0x01) == 0) {
-    return v8::Number::New(addr >> 1);
-  } else {
-    return v8::External::New(cptr);
-  }
+  ASSERT((addr & 0x01) == 0);  // the address must be aligned.
+  return v8::Integer::New(addr >> 1);
 }
 
 
 void* V8Proxy::ExtractCPointerImpl(v8::Handle<v8::Value> obj) {
-  if (obj->IsNumber()) {
-    int addr = obj->Int32Value();
-    return reinterpret_cast<void*>(addr << 1);
-  } else if (obj->IsExternal()) {
-    return v8::Handle<v8::External>::Cast(obj)->Value();
-  }
-  ASSERT(false);
-  return 0;
+  ASSERT(obj->IsNumber());
+  int addr = obj->Int32Value();
+  return reinterpret_cast<void*>(addr << 1);
 }
 
 
-bool V8Proxy::SetDOMWrapper(v8::Handle<v8::Object> obj, int type, void* cptr) {
+void V8Proxy::SetDOMWrapper(v8::Handle<v8::Object> obj, int type, void* cptr) {
   ASSERT(obj->InternalFieldCount() >= 2);
   obj->SetInternalField(V8Custom::kDOMWrapperObjectIndex, WrapCPointer(cptr));
   obj->SetInternalField(V8Custom::kDOMWrapperTypeIndex, v8::Integer::New(type));
-  return true;
 }
 
 
+#ifndef NDEBUG
 bool V8Proxy::MaybeDOMWrapper(v8::Handle<v8::Value> value) {
   if (value.IsEmpty() || !value->IsObject()) return false;
 
   v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(value);
-  if (obj->InternalFieldCount() < V8Custom::kDefaultWrapperInternalFieldCount)
-    return false;
+  if (obj->InternalFieldCount() == 0) return false;
+
+  ASSERT(obj->InternalFieldCount() >=
+         V8Custom::kDefaultWrapperInternalFieldCount);
+
+  v8::Handle<v8::Value> type =
+      obj->GetInternalField(V8Custom::kDOMWrapperTypeIndex);
+  ASSERT(type->IsInt32());
+  ASSERT(V8ClassIndex::INVALID_CLASS_INDEX < type->Int32Value() &&
+    type->Int32Value() < V8ClassIndex::CLASSINDEX_END);
 
   v8::Handle<v8::Value> wrapper =
       obj->GetInternalField(V8Custom::kDOMWrapperObjectIndex);
-  if (!wrapper->IsNumber() && !wrapper->IsExternal()) return false;
+  ASSERT(wrapper->IsNumber() || wrapper->IsExternal());
+
+  return true;
+}
+#endif
+
+
+bool V8Proxy::IsDOMEventWrapper(v8::Handle<v8::Value> value) {
+  if (value.IsEmpty() || !value->IsObject()) return false;
+
+  v8::Handle<v8::Object> obj = v8::Handle<v8::Object>::Cast(value);
+  if (obj->InternalFieldCount() == 0) return false;
+
+  ASSERT(obj->InternalFieldCount() >=
+         V8Custom::kDefaultWrapperInternalFieldCount);
+
+  v8::Handle<v8::Value> wrapper =
+      obj->GetInternalField(V8Custom::kDOMWrapperObjectIndex);
+  ASSERT(wrapper->IsNumber() || wrapper->IsExternal());
 
   v8::Handle<v8::Value> type =
       obj->GetInternalField(V8Custom::kDOMWrapperTypeIndex);
-  if (!type->IsNumber()) return false;
+  ASSERT(type->IsInt32());
+  ASSERT(V8ClassIndex::INVALID_CLASS_INDEX < type->Int32Value() &&
+    type->Int32Value() < V8ClassIndex::CLASSINDEX_END);
 
-  return true;
+  // All kinds of events use EVENT as dom type in JS wrappers.
+  // See EventToV8Object
+  return V8ClassIndex::FromInt(type->Int32Value()) == V8ClassIndex::EVENT;
 }
 
 
 #define FOR_EACH_TAG(macro)                      \
   macro(a, ANCHOR)                               \
   macro(applet, APPLET)                          \
   macro(area, AREA)                              \
   macro(base, BASE)                              \
   macro(basefont, BASEFONT)                      \
   macro(blockquote, BLOCKQUOTE)                  \
@@ skipping 225 matching lines @@
   else if (event->isUIEvent())
     type = V8ClassIndex::UIEVENT;
   else if (event->isMutationEvent())
     type = V8ClassIndex::MUTATIONEVENT;
   else if (event->isOverflowEvent())
     type = V8ClassIndex::OVERFLOWEVENT;
   else if (event->isProgressEvent())
     type = V8ClassIndex::PROGRESSEVENT;
 
   // Set the peer object for future access.
-  v8::Handle<v8::Object> result = InstantiateV8Object(type, event);
+  v8::Handle<v8::Object> result =
+      InstantiateV8Object(type, V8ClassIndex::EVENT, event);
   if (result.IsEmpty()) {
     // Instantiation failed. Avoid updating the DOM object map and
     // return null which is already handled by callers of this function
     // in case the event is NULL.
     return v8::Null();
   }
 
   dom_object_map().set(event, v8::Persistent<v8::Object>::New(result));
 
   return result;
 }
 
 
-v8::Handle<v8::Object> V8Proxy::NodeToV8Object(Node* node) {
-  if (!node) return v8::Handle<v8::Object>();
+// Caller checks node is not null.
+v8::Handle<v8::Value> V8Proxy::NodeToV8Object(Node* node) {
+  if (!node) return v8::Null();
 
   v8::Handle<v8::Object> peer = dom_node_map().get(node);
   if (!peer.IsEmpty()) {
     return peer;
   }
 
   bool is_document = false;  // document type node has special handling
   V8ClassIndex::V8WrapperType type;
 
   switch (node->nodeType()) {
@@ skipping 51 matching lines @@
       break;
     case Node::ENTITY_REFERENCE_NODE:
       type = V8ClassIndex::ENTITYREFERENCE;
       break;
     default:
       type = V8ClassIndex::NODE;
   }
 
   // Set the peer object for future access.
   // InstantiateV8Object automatically casts node to Peerable*.
-  v8::Local<v8::Object> result = InstantiateV8Object(type, node);
+  v8::Local<v8::Object> result =
+      InstantiateV8Object(type, V8ClassIndex::NODE, node);
   if (result.IsEmpty()) {
     // If instantiation failed it's important not to add the result
     // to the DOM node map. Instead we return an empty handle, which
     // should already be handled by callers of this function in case
     // the node is NULL.
     return result;
   }
 
   dom_node_map().set(node, v8::Persistent<v8::Object>::New(result));
 
@@ skipping 70 matching lines @@
   // TODO(fqian): can a user take a lazy event listener and set to other places?
   V8AbstractEventListener* v8listener =
       static_cast<V8AbstractEventListener*>(listener);
   return v8listener->GetListenerObject();
 }
 
 
 v8::Handle<v8::Value> V8Proxy::DOMImplementationToV8Object(
     DOMImplementation* impl) {
   v8::Handle<v8::Object> result =
-    InstantiateV8Object(V8ClassIndex::DOMIMPLEMENTATION, impl);
+    InstantiateV8Object(V8ClassIndex::DOMIMPLEMENTATION,
+                        V8ClassIndex::DOMIMPLEMENTATION,
+                        impl);
   if (result.IsEmpty()) {
     // If the instantiation failed, we ignore it and return null instead
     // of returning an empty handle.
     return v8::Null();
   }
   return result;
 }
 
 
-v8::Handle<v8::Object> V8Proxy::StyleSheetToV8Object(StyleSheet* sheet) {
-  if (!sheet) return v8::Handle<v8::Object>();
+v8::Handle<v8::Value> V8Proxy::StyleSheetToV8Object(StyleSheet* sheet) {
+  if (!sheet) return v8::Null();
 
   v8::Handle<v8::Object> peer = dom_object_map().get(sheet);
   if (!peer.IsEmpty()) {
     return peer;
   }
 
   V8ClassIndex::V8WrapperType type = V8ClassIndex::STYLESHEET;
   if (sheet->isCSSStyleSheet()) type = V8ClassIndex::CSSSTYLESHEET;
 
-  v8::Handle<v8::Object> result = InstantiateV8Object(type, sheet);
+  v8::Handle<v8::Object> result =
+      InstantiateV8Object(type, V8ClassIndex::STYLESHEET, sheet);
   if (!result.IsEmpty()) {
     // Only update the DOM object map if the result is non-empty.
     dom_object_map().set(sheet, v8::Persistent<v8::Object>::New(result));
   }
 
   // Add a hidden reference from stylesheet object to its owner node.
   Node* owner_node = sheet->ownerNode();
   if (owner_node) {
-    v8::Handle<v8::Object> owner = NodeToV8Object(owner_node);
+    v8::Handle<v8::Object> owner =
+      v8::Handle<v8::Object>::Cast(NodeToV8Object(owner_node));
     result->SetInternalField(V8Custom::kStyleSheetOwnerNodeIndex, owner);
   }
 
   return result;
 }
 
 
-v8::Handle<v8::Object> V8Proxy::CSSValueToV8Object(CSSValue* value) {
-  if (!value) return v8::Handle<v8::Object>();
+v8::Handle<v8::Value> V8Proxy::CSSValueToV8Object(CSSValue* value) {
+  if (!value) return v8::Null();
 
   v8::Handle<v8::Object> peer = dom_object_map().get(value);
   if (!peer.IsEmpty()) {
     return peer;
   }
 
   V8ClassIndex::V8WrapperType type;
 
   if (value->isValueList())
     type = V8ClassIndex::CSSVALUELIST;
   else if (value->isPrimitiveValue())
     type = V8ClassIndex::CSSPRIMITIVEVALUE;
 #if ENABLE(SVG)
   else if (value->isSVGPaint())
     type = V8ClassIndex::SVGPAINT;
   else if (value->isSVGColor())
     type = V8ClassIndex::SVGCOLOR;
 #endif
   else
     type = V8ClassIndex::CSSVALUE;
 
-  v8::Handle<v8::Object> result = InstantiateV8Object(type, value);
+  v8::Handle<v8::Object> result =
+      InstantiateV8Object(type, V8ClassIndex::CSSVALUE, value);
   if (!result.IsEmpty()) {
     // Only update the DOM object map if the result is non-empty.
     dom_object_map().set(value, v8::Persistent<v8::Object>::New(result));
   }
   return result;
 }
 
 
-v8::Handle<v8::Object> V8Proxy::CSSRuleToV8Object(CSSRule* rule) {
-  if (!rule) return v8::Handle<v8::Object>();
+v8::Handle<v8::Value> V8Proxy::CSSRuleToV8Object(CSSRule* rule) {
+  if (!rule) return v8::Null();
 
   v8::Handle<v8::Object> peer = dom_object_map().get(rule);
   if (!peer.IsEmpty()) {
     return peer;
   }
 
   V8ClassIndex::V8WrapperType type;
 
   switch (rule->type()) {
   case CSSRule::STYLE_RULE:
@@ skipping 12 matching lines @@
     type = V8ClassIndex::CSSFONTFACERULE;
     break;
   case CSSRule::PAGE_RULE:
     type = V8ClassIndex::CSSPAGERULE;
     break;
   default:  // CSSRule::UNKNOWN_RULE
     type = V8ClassIndex::CSSRULE;
   }
 
   // Set the peer object for future access.
-  v8::Handle<v8::Object> result = InstantiateV8Object(type, rule);
+  v8::Handle<v8::Object> result =
+      InstantiateV8Object(type, V8ClassIndex::CSSRULE, rule);
   if (!result.IsEmpty()) {
     // Only update the DOM object map if the result is non-empty.
     dom_object_map().set(rule, v8::Persistent<v8::Object>::New(result));
   }
   return result;
 }
 
-v8::Handle<v8::Object> V8Proxy::WindowToV8Object(DOMWindow* window) {
+v8::Handle<v8::Value> V8Proxy::WindowToV8Object(DOMWindow* window) {
+  if (!window) return v8::Null();
+
   // Initializes environment of a frame, and return the global object
   // of the frame.
   Frame* frame = window->frame();
   if (!frame) return v8::Handle<v8::Object>();
 
   v8::Handle<v8::Context> context = GetContext(frame);
   if (context.IsEmpty()) return v8::Handle<v8::Object>();
 
   v8::Handle<v8::Object> global = context->Global();
   ASSERT(!global.IsEmpty());
@@ skipping 18 matching lines @@
   global->Set(v8::String::New(name), instance);
 }
 
 
 void V8Proxy::ProcessConsoleMessages() {
   ConsoleMessageManager::ProcessDelayedMessages();
 }
 
 
 }  // namespace WebCore