Implement better JS exception handling by abstracting KJS::ExecState into an ...

webkit/port/bindings/v8/v8_custom.cpp

 /*
  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
  *  Copyright (C) 2004-2006 Apple Computer, Inc.
  *  Copyright (C) 2006 James G. Speth (speth@end.com)
  *  Copyright (C) 2006 Samuel Weinig (sam@webkit.org)
  *  Copyright 2007, 2008 Google Inc. All Rights Reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ skipping 25 matching lines @@
 #include "V8Attr.h"
 #include "V8CanvasGradient.h"
 #include "V8CanvasPattern.h"
 #include "V8Document.h"
 #include "V8DOMWindow.h"
 #include "V8HTMLCanvasElement.h"
 #include "V8HTMLDocument.h"
 #include "V8HTMLImageElement.h"
 #include "V8HTMLOptionElement.h"
 #include "V8Node.h"
+#include "V8NSResolver.h"
 #include "V8XPathNSResolver.h"
 #include "V8XPathResult.h"
 
 #include "CanvasGradient.h"
 #include "CanvasPattern.h"
 #include "CanvasStyle.h"
 #include "CanvasRenderingContext2D.h"
 
 #include "Clipboard.h"
 #include "ClipboardEvent.h"
@@ skipping 37 matching lines @@
 #include "NodeIterator.h"
 #include "Page.h"
 #include "PlatformScreen.h"
 #include "RenderWidget.h"
 #include "RenderPartObject.h"
 #include "RGBColor.h"
 #include "SecurityOrigin.h"
 #include "Settings.h"
 #include "StyleSheetList.h"
 #include "TreeWalker.h"
+#include "JSNSResolver.h"
 #include "WindowFeatures.h"
 #include "XPathEvaluator.h"
 #include "JSXPathNSResolver.h"
 #include "XPathResult.h"
 #include "XSLTProcessor.h"
 
 #if ENABLE(SVG)
 #include "V8SVGPODTypeWrapper.h"
 #include "SVGException.h"
 #include "SVGPathSeg.h"
@@ skipping 2225 matching lines @@
       return false;
   }
   return true;
 }
 
 
 // Element ---------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(ElementQuerySelector) {
   INC_STATS(L"DOM.Element.querySelector()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  Element* element = V8Proxy::FastToNativeObject<Element>(
+      V8ClassIndex::ELEMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if  (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Element> result = WTF::getPtr(
+      element->querySelector(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, WTF::getPtr(result));
 }
 
 CALLBACK_FUNC_DECL(ElementQuerySelectorAll) {
   INC_STATS(L"DOM.Element.querySelectorAll()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  Element* element = V8Proxy::FastToNativeObject<Element>(
+      V8ClassIndex::ELEMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<NodeList> result = WTF::getPtr(
+      element->querySelectorAll(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODELIST, WTF::getPtr(result));
 }
 
 CALLBACK_FUNC_DECL(ElementSetAttribute) {
   INC_STATS(L"DOM.Element.setAttribute()");
   Element* imp = V8Proxy::FastToNativeObject<Element>(
       V8ClassIndex::ELEMENT, args.Holder());
   ExceptionCode ec = 0;
   String name = ToWebCoreString(args[0]);
   String value = ToWebCoreString(args[1]);
 
@@ skipping 323 matching lines @@
   if (ec != 0) {
     V8Proxy::SetDOMException(ec);
     return v8::Handle<v8::Value>();
   }
   return V8Proxy::ToV8Object(V8ClassIndex::XPATHRESULT,
                              static_cast<Peerable*>(result.get()));
 }
 
 CALLBACK_FUNC_DECL(DocumentQuerySelector) {
   INC_STATS(L"DOM.Document.querySelector()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  Document* document = V8Proxy::FastToNativeObject<Document>(
+      V8ClassIndex::DOCUMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Element> result = WTF::getPtr(
+      document->querySelector(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, WTF::getPtr(result));
 }
 
 CALLBACK_FUNC_DECL(DocumentQuerySelectorAll) {
   INC_STATS(L"DOM.Document.querySelectorAll()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  Document* document = V8Proxy::FastToNativeObject<Document>(
+      V8ClassIndex::DOCUMENTFRAGMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<NodeList> result = WTF::getPtr(
+      document->querySelectorAll(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODELIST, WTF::getPtr(result));
 }
 
 CALLBACK_FUNC_DECL(DocumentFragmentQuerySelector) {
   INC_STATS(L"DOM.DocumentFragment.querySelector()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  DocumentFragment* fragment = V8Proxy::FastToNativeObject<DocumentFragment>(
+      V8ClassIndex::DOCUMENTFRAGMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Element> result = WTF::getPtr(
+      fragment->querySelector(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, WTF::getPtr(result));
 }
 
 CALLBACK_FUNC_DECL(DocumentFragmentQuerySelectorAll) {
   INC_STATS(L"DOM.DocumentFragment.querySelectorAll()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  DocumentFragment* fragment = V8Proxy::FastToNativeObject<DocumentFragment>(
+      V8ClassIndex::DOCUMENTFRAGMENT, args.Holder());
+  ExceptionCode ec = 0;
+
+  String selectors = valueToStringWithNullOrUndefinedCheck(args[0]);
+
+  NSResolver* resolver = 0;
+  if (V8NSResolver::HasInstance(args[1])) {
+    resolver = V8Proxy::FastToNativeObject<NSResolver>(
+      V8ClassIndex::NSRESOLVER, args[1]);
+  } else if (args[1]->IsObject()) {
+    if (!args[1]->IsNull())
+        resolver = new JSNSResolver(args[1]->ToObject());
+  } else if (!args[1]->IsUndefined()) {
+    V8Proxy::SetDOMException(TYPE_MISMATCH_ERR);
+    return v8::Handle<v8::Value>();
+  }
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<NodeList> result = WTF::getPtr(
+      fragment->querySelectorAll(selectors, resolver, ec, context.get()));
+  if (ec != 0) {
+    V8Proxy::SetDOMException(ec);
+    return v8::Handle<v8::Value>();
+  }
+  return V8Proxy::ToV8Object(V8ClassIndex::NODELIST, WTF::getPtr(result));
 }
 
-
 // DOMWindow -------------------------------------------------------------------
 
 static bool IsAscii(const String& str) {
   for (size_t i = 0; i < str.length(); i++) {
     if (str[i] > 0xFF)
       return false;
   }
   return true;
 }
 
@@ skipping 472 matching lines @@
   INC_STATS(L"DOM.XMLHttpRequestUpload.dispatchEvent()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
   return v8::Undefined();
 }
 
 
 // TreeWalker ------------------------------------------------------------------
 
 CALLBACK_FUNC_DECL(TreeWalkerParentNode) {
   INC_STATS(L"DOM.TreeWalker.parentNode()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->parentNode(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerFirstChild) {
   INC_STATS(L"DOM.TreeWalker.firstChild()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->firstChild(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerLastChild) {
   INC_STATS(L"DOM.TreeWalker.lastChild()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->lastChild(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextNode) {
   INC_STATS(L"DOM.TreeWalker.nextNode()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->nextNode(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousNode) {
   INC_STATS(L"DOM.TreeWalker.previousNode()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->previousNode(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerNextSibling) {
   INC_STATS(L"DOM.TreeWalker.nextSibling()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->nextSibling(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(TreeWalkerPreviousSibling) {
   INC_STATS(L"DOM.TreeWalker.previousSibling()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  TreeWalker* treeWalker = V8Proxy::FastToNativeObject<TreeWalker>(
+      V8ClassIndex::TREEWALKER, args.Holder());
+
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = treeWalker->previousSibling(context.get());
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorNextNode) {
   INC_STATS(L"DOM.NodeIterator.nextNode()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  NodeIterator* nodeIterator = V8Proxy::FastToNativeObject<NodeIterator>(
+      V8ClassIndex::NODEITERATOR, args.Holder());
+
+  ExceptionCode ec = 0;
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = nodeIterator->nextNode(context.get(), ec);
+  if (ec != 0) {
+      V8Proxy::SetDOMException(ec);
+      return v8::Null();
+  }
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeIteratorPreviousNode) {
   INC_STATS(L"DOM.NodeIterator.previousNode()");
-  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
-  return v8::Undefined();
+  NodeIterator* nodeIterator = V8Proxy::FastToNativeObject<NodeIterator>(
+      V8ClassIndex::NODEITERATOR, args.Holder());
+
+  ExceptionCode ec = 0;
+  OwnPtr<ExceptionContext> context(new ExceptionContext());
+  RefPtr<Node> result = nodeIterator->previousNode(context.get(), ec);
+  if (ec != 0) {
+      V8Proxy::SetDOMException(ec);
+      return v8::Null();
+  }
+  if (context->hadException()) {
+    v8::ThrowException(context->exception());
+    return v8::Undefined();
+  }
+  if (!result) return v8::Null();
+  return V8Proxy::ToV8Object(V8ClassIndex::NODE, result.get());
 }
 
 CALLBACK_FUNC_DECL(NodeFilterAcceptNode) {
   INC_STATS(L"DOM.NodeFilter.acceptNode()");
   V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);  
   return v8::Undefined();
 }
 
+// NSResolver
+CALLBACK_FUNC_DECL(NSResolverLookupNamespaceURI) {
+  INC_STATS(L"DOM.NSResolver.lookupNamespaceURI()");
+  V8Proxy::SetDOMException(NOT_SUPPORTED_ERR);
+  return v8::Undefined();
+}
+
 ACCESSOR_SETTER(DOMWindowEventHandler) {
   v8::Handle<v8::Object> holder = V8Proxy::LookupDOMWrapper(
       V8ClassIndex::DOMWINDOW, info.This());
   if (holder.IsEmpty())
     return;
 
   DOMWindow* imp = V8Proxy::FastToNativeObject<DOMWindow>(
       V8ClassIndex::DOMWINDOW, holder);
   if (!imp->frame())
     return;
@@ skipping 334 matching lines @@
 #undef MAKE_CASE
 
   default:
     return V8ClassIndex::INVALID_CLASS_INDEX;
   }
 }
 
 #endif  // ENABLE(SVG)
 
 }  // namespace WebCore