Revert change 12507 and 12532 because it breaks the ...

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 18 matching lines @@
 
 #include "config.h"
 
 #include <algorithm>
 #include <utility>
 
 #include <v8.h>
 #include <v8-debug.h>
 
 #include "v8_proxy.h"
+#include "dom_wrapper_map.h"
 #include "v8_index.h"
 #include "v8_binding.h"
 #include "v8_custom.h"
 #include "v8_nodefilter.h"
 #include "V8Collection.h"
 #include "V8DOMWindow.h"
 
 #include "ChromiumBridge.h"
-#include "DOMObjectsInclude.h"
+
+#include "BarInfo.h"
+#include "CanvasGradient.h"
+#include "CanvasPattern.h"
+#include "CanvasPixelArray.h"
+#include "CanvasRenderingContext2D.h"
+#include "CanvasStyle.h"
+#include "CharacterData.h"
+#include "ClientRect.h"
+#include "ClientRectList.h"
+#include "Clipboard.h"
+#include "Console.h"
+#include "Counter.h"
+#include "CSSCharsetRule.h"
+#include "CSSFontFaceRule.h"
+#include "CSSImportRule.h"
+#include "CSSMediaRule.h"
+#include "CSSPageRule.h"
+#include "CSSRule.h"
+#include "CSSRuleList.h"
+#include "CSSValueList.h"
+#include "CSSStyleRule.h"
+#include "CSSStyleSheet.h"
+#include "CSSVariablesDeclaration.h"
+#include "CSSVariablesRule.h"
+#include "Database.h"
+#include "DocumentType.h"
+#include "DocumentFragment.h"
+#include "DOMCoreException.h"
+#include "DOMImplementation.h"
+#include "DOMParser.h"
+#include "DOMSelection.h"
+#include "DOMStringList.h"
+#include "DOMWindow.h"
+#include "Entity.h"
+#include "EventListener.h"
+#include "EventTarget.h"
+#include "Event.h"
+#include "EventException.h"
+#include "ExceptionCode.h"
+#include "File.h"
+#include "FileList.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameTree.h"
+#include "History.h"
+#include "HTMLNames.h"
+#include "HTMLDocument.h"
+#include "HTMLElement.h"
+#include "HTMLImageElement.h"
+#include "HTMLInputElement.h"
+#include "HTMLSelectElement.h"
+#include "HTMLOptionsCollection.h"
+#include "ImageData.h"
+#include "InspectorController.h"
+#include "KeyboardEvent.h"
+#include "Location.h"
+#include "MediaError.h"
+#include "MediaList.h"
+#include "MediaPlayer.h"
+#include "MessageChannel.h"
+#include "MessageEvent.h"
+#include "MessagePort.h"
+#include "MimeTypeArray.h"
+#include "MouseEvent.h"
+#include "MutationEvent.h"
+#include "Navigator.h"  // for MimeTypeArray
+#include "NodeFilter.h"
+#include "Notation.h"
+#include "NodeList.h"
+#include "NodeIterator.h"
+#include "OverflowEvent.h"
+#include "Page.h"
+#include "Plugin.h"
+#include "PluginArray.h"
+#include "ProcessingInstruction.h"
+#include "ProgressEvent.h"
+#include "Range.h"
+#include "RangeException.h"
+#include "Rect.h"
+#include "RGBColor.h"
+#include "Screen.h"
+#include "ScriptExecutionContext.h"
+#include "SecurityOrigin.h"
+#include "Settings.h"
+#include "SQLTransaction.h"
+#include "SQLResultSet.h"
+#include "SQLResultSetRowList.h"
+#include "StyleSheet.h"
+#include "StyleSheetList.h"
+#include "SVGColor.h"
+#include "SVGPaint.h"
+#include "TextEvent.h"
+#include "TextMetrics.h"
+#include "TimeRanges.h"
+#include "TreeWalker.h"
+#include "XSLTProcessor.h"
+#include "V8AbstractEventListener.h"
+#include "V8CustomEventListener.h"
+#include "V8DOMWindow.h"
+#include "V8HTMLElement.h"
+#include "V8LazyEventListener.h"
+#include "V8ObjectEventListener.h"
+#include "WebKitAnimationEvent.h"
+#include "WebKitCSSKeyframeRule.h"
+#include "WebKitCSSKeyframesRule.h"
+#include "WebKitCSSMatrix.h"
+#include "WebKitCSSTransformValue.h"
+#include "WebKitPoint.h"
+#include "WebKitTransitionEvent.h"
+#include "WheelEvent.h"
+#include "XMLHttpRequest.h"
+#include "XMLHttpRequestException.h"
+#include "XMLHttpRequestProgressEvent.h"
+#include "XMLHttpRequestUpload.h"
+#include "XMLSerializer.h"
+#include "XPathException.h"
+#include "XPathExpression.h"
+#include "XPathNSResolver.h"
+#include "XPathResult.h"
+
 
 #include "ScriptController.h"
 
+#if ENABLE(SVG)
+#include "SVGAngle.h"
+#include "SVGAnimatedPoints.h"
+#include "SVGElement.h"
+#include "SVGElementInstance.h"
+#include "SVGElementInstanceList.h"
+#include "SVGException.h"
+#include "SVGLength.h"
+#include "SVGLengthList.h"
+#include "SVGNumberList.h"
+#include "SVGPathSeg.h"
+#include "SVGPathSegArc.h"
+#include "SVGPathSegClosePath.h"
+#include "SVGPathSegCurvetoCubic.h"
+#include "SVGPathSegCurvetoCubicSmooth.h"
+#include "SVGPathSegCurvetoQuadratic.h"
+#include "SVGPathSegCurvetoQuadraticSmooth.h"
+#include "SVGPathSegLineto.h"
+#include "SVGPathSegLinetoHorizontal.h"
+#include "SVGPathSegLinetoVertical.h"
+#include "SVGPathSegList.h"
+#include "SVGPathSegMoveto.h"
+#include "SVGPointList.h"
+#include "SVGPreserveAspectRatio.h"
+#include "SVGRenderingIntent.h"
+#include "SVGStringList.h"
+#include "SVGTransform.h"
+#include "SVGTransformList.h"
+#include "SVGUnitTypes.h"
+#include "SVGURIReference.h"
+#include "SVGZoomEvent.h"
+#include "V8SVGPODTypeWrapper.h"
+#endif  // SVG
+
+#if ENABLE(WORKERS)
+#include "Worker.h"
+#include "WorkerContext.h"
+#include "WorkerLocation.h"
+#include "WorkerNavigator.h"
+#endif  // WORKERS
+
+#if ENABLE(XPATH)
+#include "XPathEvaluator.h"
+#endif
+
+
 namespace WebCore {
 
+
+// DOM binding algorithm:
+//
+// There are two kinds of DOM objects:
+// 1. DOM tree nodes, such as Document, HTMLElement, ...
+//    there classes implements TreeShared<T> interface;
+// 2. Non-node DOM objects, such as CSSRule, Location, etc.
+//    these classes implement a ref-counted scheme.
+//
+// A DOM object may have a JS wrapper object. If a tree node
+// is alive, its JS wrapper must be kept alive even it is not
+// reachable from JS roots.
+// However, JS wrappers of non-node objects can go away if
+// not reachable from other JS objects. It works like a cache.
+//
+// DOM objects are ref-counted, and JS objects are traced from
+// a set of root objects. They can create a cycle. To break
+// cycles, we do following:
+//   Handles from DOM objects to JS wrappers are always weak,
+// so JS wrappers of non-node object cannot create a cycle.
+//   Before starting a global GC, we create a virtual connection
+// between nodes in the same tree in the JS heap. If the wrapper
+// of one node in a tree is alive, wrappers of all nodes in
+// the same tree are considered alive. This is done by creating
+// object groups in GC prologue callbacks. The mark-compact
+// collector will remove these groups after each GC.
+
+
 // Static utility context.
 v8::Persistent<v8::Context> V8Proxy::m_utilityContext;
 
 // Static list of registered extensions
 V8ExtensionList V8Proxy::m_extensions;
 
 
+// A helper class for undetectable document.all
+class UndetectableHTMLCollection : public HTMLCollection {
+};
+
 #ifndef NDEBUG
 // Keeps track of global handles created (not JS wrappers
 // of DOM objects). Often these global handles are source
 // of leaks.
 //
 // If you want to let a C++ object hold a persistent handle
 // to a JS object, you should register the handle here to
 // keep track of leaks.
 //
 // When creating a persistent handle, call:
@@ skipping 109 matching lines @@
 {
   for (DOMNodeMap::iterator it = node_map.begin(), end = node_map.end();
     it != end; ++it) {
     Node* node = it->first;
     USE_VAR(node);
     ASSERT(v8::Persistent<v8::Object>(it->second).IsWeak());
   }
 }
 #endif  // NDEBUG
 
+static void WeakDOMObjectCallback(v8::Persistent<v8::Value> obj, void* para);
+static void WeakActiveDOMObjectCallback(v8::Persistent<v8::Value> obj,
+                                        void* para);
+static void WeakNodeCallback(v8::Persistent<v8::Value> obj, void* para);
+// A map from DOM node to its JS wrapper.
+static DOMWrapperMap<Node>& GetDOMNodeMap()
+{
+  static DOMWrapperMap<Node> static_dom_node_map(&WeakNodeCallback);
+  return static_dom_node_map;
+}
+
+
+// A map from a DOM object (non-node) to its JS wrapper. This map does not
+// contain the DOM objects which can have pending activity (active dom objects).
+DOMWrapperMap<void>& GetDOMObjectMap()
+{
+  static DOMWrapperMap<void>
+    static_dom_object_map(&WeakDOMObjectCallback);
+  return static_dom_object_map;
+}
+
+
+// A map from a DOM object to its JS wrapper for DOM objects which
+// can have pending activity.
+static DOMWrapperMap<void>& GetActiveDOMObjectMap()
+{
+  static DOMWrapperMap<void>
+    static_active_dom_object_map(&WeakActiveDOMObjectCallback);
+  return static_active_dom_object_map;
+}
+
 #if ENABLE(SVG)
+static void WeakSVGElementInstanceCallback(v8::Persistent<v8::Value> obj,
+                                           void* param);
+
+// A map for SVGElementInstances.
+static DOMWrapperMap<SVGElementInstance>& dom_svg_element_instance_map()
+{
+  static DOMWrapperMap<SVGElementInstance>
+      static_dom_svg_element_instance_map(&WeakSVGElementInstanceCallback);
+  return static_dom_svg_element_instance_map;
+}
+
+static void WeakSVGElementInstanceCallback(v8::Persistent<v8::Value> 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::Value> V8Proxy::SVGElementInstanceToV8Object(
     SVGElementInstance* instance)
 {
   if (!instance)
     return v8::Null();
 
-  v8::Handle<v8::Object> existing_instance = getDOMSVGElementInstanceMap().get(instance);
+  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,
                           V8ClassIndex::SVGELEMENTINSTANCE,
                           instance);
   if (!result.IsEmpty()) {
     // Only update the DOM SVG element map if the result is non-empty.
-    getDOMSVGElementInstanceMap().set(instance,
+    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 change
+static void WeakSVGObjectWithContext(v8::Persistent<v8::Value> obj,
+                                     void* dom_obj);
+
+// Map of SVG objects with contexts to V8 objects
+static DOMWrapperMap<void>& dom_svg_object_with_context_map() {
+    static DOMWrapperMap<void>
+        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::Value> V8Proxy::SVGObjectWithContextToV8Object(
     V8ClassIndex::V8WrapperType type, void* object)
 {
   if (!object)
     return v8::Null();
 
   v8::Persistent<v8::Object> result =
-    getDOMSVGObjectWithContextMap().get(object);
+    dom_svg_object_with_context_map().get(object);
   if (!result.IsEmpty()) return result;
 
   // Special case: SVGPathSegs need to be downcast to their real type
   if (type == V8ClassIndex::SVGPATHSEG)
     type = V8Custom::DowncastSVGPathSeg(object);
 
   v8::Local<v8::Object> v8obj = InstantiateV8Object(type, type, object);
   if (!v8obj.IsEmpty()) {
     result = v8::Persistent<v8::Object>::New(v8obj);
     switch (type) {
 #define MAKE_CASE(TYPE, NAME)     \
       case V8ClassIndex::TYPE: static_cast<NAME*>(object)->ref(); break;
 SVG_OBJECT_TYPES(MAKE_CASE)
 #undef MAKE_CASE
 #define MAKE_CASE(TYPE, NAME)     \
       case V8ClassIndex::TYPE:    \
         static_cast<V8SVGPODTypeWrapper<NAME>*>(object)->ref(); break;
 SVG_POD_NATIVE_TYPES(MAKE_CASE)
 #undef MAKE_CASE
       default:
         ASSERT(false);
     }
-    getDOMSVGObjectWithContextMap().set(object, result);
+    dom_svg_object_with_context_map().set(object, result);
   }
 
   return result;
 }
 
-// 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;
+static void WeakSVGObjectWithContext(v8::Persistent<v8::Value> obj,
+                                     void* dom_obj)
+{
+  v8::HandleScope handle_scope;
+  ASSERT(dom_svg_object_with_context_map().contains(dom_obj));
+  ASSERT(obj->IsObject());
+
+  // Forget function removes object from the map and dispose the wrapper.
+  dom_svg_object_with_context_map().forget(dom_obj);
+
+  V8ClassIndex::V8WrapperType type =
+    V8Proxy::GetDOMWrapperType(v8::Handle<v8::Object>::Cast(obj));
+
+  switch (type) {
+#define MAKE_CASE(TYPE, NAME)     \
+    case V8ClassIndex::TYPE: static_cast<NAME*>(dom_obj)->deref(); break;
+SVG_OBJECT_TYPES(MAKE_CASE)
+#undef MAKE_CASE
+#define MAKE_CASE(TYPE, NAME)     \
+    case V8ClassIndex::TYPE:      \
+      static_cast<V8SVGPODTypeWrapper<NAME>*>(dom_obj)->deref(); break;
+SVG_POD_NATIVE_TYPES(MAKE_CASE)
+#undef MAKE_CASE
+    default:
+      ASSERT(false);
+  }
 }
 
 void V8Proxy::SetSVGContext(void* obj, SVGElement* context)
 {
   SVGElement* old_context = svg_object_to_context_map().get(obj);
 
   if (old_context == context)
     return;
 
   if (old_context)
     old_context->deref();
 
   if (context)
     context->ref();
 
   svg_object_to_context_map().set(obj, context);
 }
 
 SVGElement* V8Proxy::GetSVGContext(void* obj)
 {
     return svg_object_to_context_map().get(obj);
 }
+
 #endif
 
+// Called when obj is near death (not reachable from JS roots)
+// It is time to remove the entry from the table and dispose
+// the handle.
+static void WeakDOMObjectCallback(v8::Persistent<v8::Value> obj,
+                                  void* dom_obj) {
+  v8::HandleScope scope;
+  ASSERT(GetDOMObjectMap().contains(dom_obj));
+  ASSERT(obj->IsObject());
+
+  // Forget function removes object from the map and dispose the wrapper.
+  GetDOMObjectMap().forget(dom_obj);
+
+  V8ClassIndex::V8WrapperType type =
+    V8Proxy::GetDOMWrapperType(v8::Handle<v8::Object>::Cast(obj));
+  switch (type) {
+#define MAKE_CASE(TYPE, NAME)   \
+    case V8ClassIndex::TYPE: static_cast<NAME*>(dom_obj)->deref(); break;
+    DOM_OBJECT_TYPES(MAKE_CASE)
+#undef MAKE_CASE
+    default:
+      ASSERT(false);
+  }
+}
+
+
+static void WeakActiveDOMObjectCallback(v8::Persistent<v8::Value> obj,
+                                        void* dom_obj)
+{
+  v8::HandleScope scope;
+  ASSERT(GetActiveDOMObjectMap().contains(dom_obj));
+  ASSERT(obj->IsObject());
+
+  // Forget function removes object from the map and dispose the wrapper.
+  GetActiveDOMObjectMap().forget(dom_obj);
+
+  V8ClassIndex::V8WrapperType type =
+    V8Proxy::GetDOMWrapperType(v8::Handle<v8::Object>::Cast(obj));
+  switch (type) {
+#define MAKE_CASE(TYPE, NAME)   \
+    case V8ClassIndex::TYPE: static_cast<NAME*>(dom_obj)->deref(); break;
+    ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
+#undef MAKE_CASE
+    default:
+      ASSERT(false);
+  }
+}
+
+static void WeakNodeCallback(v8::Persistent<v8::Value> obj, void* param)
+{
+  Node* node = static_cast<Node*>(param);
+  ASSERT(GetDOMNodeMap().contains(node));
+
+  GetDOMNodeMap().forget(node);
+  node->deref();
+}
+
+
 // A map from a DOM node to its JS wrapper, the wrapper
 // is kept as a strong reference to survive GCs.
 static DOMObjectMap& gc_protected_map() {
     static DOMObjectMap static_gc_protected_map;
     return static_gc_protected_map;
 }
 
 // static
 void V8Proxy::GCProtect(void* dom_object)
 {
   if (!dom_object)
       return;
   if (gc_protected_map().contains(dom_object))
       return;
-  if (!getDOMObjectMap().contains(dom_object))
+  if (!GetDOMObjectMap().contains(dom_object))
       return;
 
   // Create a new (strong) persistent handle for the object.
-  v8::Persistent<v8::Object> wrapper = getDOMObjectMap().get(dom_object);
+  v8::Persistent<v8::Object> wrapper = GetDOMObjectMap().get(dom_object);
   if (wrapper.IsEmpty()) return;
 
   gc_protected_map().set(dom_object, *v8::Persistent<v8::Object>::New(wrapper));
 }
 
 
 // static
 void V8Proxy::GCUnprotect(void* dom_object)
 {
   if (!dom_object)
       return;
   if (!gc_protected_map().contains(dom_object))
       return;
 
   // Dispose the strong reference.
   v8::Persistent<v8::Object> wrapper(gc_protected_map().take(dom_object));
   wrapper.Dispose();
 }
 
 
 // Create object groups for DOM tree nodes.
 static void GCPrologue()
 {
   v8::HandleScope scope;
 
 #ifndef NDEBUG
-  EnumerateDOMObjectMap(getDOMObjectMap().impl());
+  EnumerateDOMObjectMap(GetDOMObjectMap().impl());
 #endif
 
   // Run through all objects with possible pending activity making their
   // wrappers non weak if there is pending activity.
-  DOMObjectMap active_map = getActiveDOMObjectMap().impl();
+  DOMObjectMap active_map = GetActiveDOMObjectMap().impl();
   for (DOMObjectMap::iterator it = active_map.begin(), end = active_map.end();
     it != end; ++it) {
     void* obj = it->first;
     v8::Persistent<v8::Object> wrapper = v8::Persistent<v8::Object>(it->second);
     ASSERT(wrapper.IsWeak());
     V8ClassIndex::V8WrapperType type = V8Proxy::GetDOMWrapperType(wrapper);
     switch (type) {
 #define MAKE_CASE(TYPE, NAME)                   \
       case V8ClassIndex::TYPE: {                \
         NAME* impl = static_cast<NAME*>(obj);   \
@@ skipping 42 matching lines @@
             V8Custom::kMessagePortEntangledPortIndex, v8::Undefined());
         }
       }
     }
   }
 
   // Create object groups.
   typedef std::pair<uintptr_t, Node*> GrouperPair;
   typedef Vector<GrouperPair> GrouperList;
 
-  DOMNodeMap node_map = getDOMNodeMap().impl();
+  DOMNodeMap node_map = GetDOMNodeMap().impl();
   GrouperList grouper;
   grouper.reserveCapacity(node_map.size());
 
   for (DOMNodeMap::iterator it = node_map.begin(), end = node_map.end();
     it != end; ++it) {
     Node* node = it->first;
 
     // If the node is in document, put it in the ownerDocument's object group.
     //
     // If an image element was created by JavaScript "new Image",
@@ skipping 45 matching lines @@
     // has one object, it has nothing else that needs to be kept alive.
     if (next_key_index - i <= 1) {
       i = next_key_index;
       continue;
     }
 
     Vector<v8::Persistent<v8::Value> > group;
     group.reserveCapacity(next_key_index - i);
     for (; i < next_key_index; ++i) {
       v8::Persistent<v8::Value> wrapper =
-          getDOMNodeMap().get(grouper[i].second);
+          GetDOMNodeMap().get(grouper[i].second);
       if (!wrapper.IsEmpty())
         group.append(wrapper);
     }
 
     if (group.size() > 1)
       v8::V8::AddObjectGroup(&group[0], group.size());
 
     ASSERT(i == next_key_index);
   }
 }
 
 
 static void GCEpilogue()
 {
   v8::HandleScope scope;
 
   // Run through all objects with pending activity making their wrappers weak
   // again.
-  DOMObjectMap active_map = getActiveDOMObjectMap().impl();
+  DOMObjectMap active_map = GetActiveDOMObjectMap().impl();
   for (DOMObjectMap::iterator it = active_map.begin(), end = active_map.end();
     it != end; ++it) {
     void* obj = it->first;
     v8::Persistent<v8::Object> wrapper = v8::Persistent<v8::Object>(it->second);
     V8ClassIndex::V8WrapperType type = V8Proxy::GetDOMWrapperType(wrapper);
     switch (type) {
 #define MAKE_CASE(TYPE, NAME)                                     \
       case V8ClassIndex::TYPE: {                                  \
         NAME* impl = static_cast<NAME*>(obj);                     \
         if (impl->hasPendingActivity()) {                         \
           ASSERT(!wrapper.IsWeak());                              \
-          wrapper.MakeWeak(impl, &weakActiveDOMObjectCallback);   \
+          wrapper.MakeWeak(impl, &WeakActiveDOMObjectCallback);   \
         }                                                         \
         break;                                                    \
       }
 ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
       default:
         ASSERT(false);
 #undef MAKE_CASE
     }
   }
 
 #ifndef NDEBUG
   // Check all survivals are weak.
-  EnumerateDOMObjectMap(getDOMObjectMap().impl());
-  EnumerateDOMNodeMap(getDOMNodeMap().impl());
+  EnumerateDOMObjectMap(GetDOMObjectMap().impl());
+  EnumerateDOMNodeMap(GetDOMNodeMap().impl());
   EnumerateDOMObjectMap(gc_protected_map());
   EnumerateGlobalHandles();
 #undef USE_VAR
 #endif
 }
 
 
 typedef HashMap<int, v8::FunctionTemplate*> FunctionTemplateMap;
 
 bool AllowAllocation::m_current = false;
@@ skipping 241 matching lines @@
 #ifndef NDEBUG
         UnregisterGlobalHandle(this, m_global);
 #endif
         m_global.Dispose();
         m_global.Clear();
     }
 }
 
 
 bool V8Proxy::DOMObjectHasJSWrapper(void* obj) {
-  return getDOMObjectMap().contains(obj) ||
-      getActiveDOMObjectMap().contains(obj);
+  return GetDOMObjectMap().contains(obj) ||
+      GetActiveDOMObjectMap().contains(obj);
 }
 
 
 // The caller must have increased obj's ref count.
 void V8Proxy::SetJSWrapperForDOMObject(void* obj, v8::Persistent<v8::Object> wrapper)
 {
     ASSERT(MaybeDOMWrapper(wrapper));
 #ifndef NDEBUG
     V8ClassIndex::V8WrapperType type = V8Proxy::GetDOMWrapperType(wrapper);
     switch (type) {
 #define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE:
 ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
       ASSERT(false);
 #undef MAKE_CASE
       default: break;
     }
 #endif
-    getDOMObjectMap().set(obj, wrapper);
+    GetDOMObjectMap().set(obj, wrapper);
 }
 
 // The caller must have increased obj's ref count.
 void V8Proxy::SetJSWrapperForActiveDOMObject(void* obj, v8::Persistent<v8::Object> wrapper)
 {
     ASSERT(MaybeDOMWrapper(wrapper));
 #ifndef NDEBUG
     V8ClassIndex::V8WrapperType type = V8Proxy::GetDOMWrapperType(wrapper);
     switch (type) {
 #define MAKE_CASE(TYPE, NAME) case V8ClassIndex::TYPE: break;
 ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
       default: ASSERT(false);
 #undef MAKE_CASE
     }
 #endif
-    getActiveDOMObjectMap().set(obj, wrapper);
+    GetActiveDOMObjectMap().set(obj, wrapper);
 }
 
 // The caller must have increased node's ref count.
 void V8Proxy::SetJSWrapperForDOMNode(Node* node, v8::Persistent<v8::Object> wrapper)
 {
     ASSERT(MaybeDOMWrapper(wrapper));
-    getDOMNodeMap().set(node, wrapper);
+    GetDOMNodeMap().set(node, wrapper);
 }
 
 PassRefPtr<EventListener> V8Proxy::createInlineEventListener(
                                                const String& functionName,
                                                const String& code, Node* node)
 {
     return V8LazyEventListener::create(m_frame, code, functionName);
 }
 
 #if ENABLE(SVG)
@@ skipping 1456 matching lines @@
     default:
       break;
   }
 
 #undef MAKE_CASE
 
   if (!imp) return v8::Null();
 
   // Non DOM node
   v8::Persistent<v8::Object> result = is_active_dom_object ?
-                                      getActiveDOMObjectMap().get(imp) :
-                                      getDOMObjectMap().get(imp);
+                                      GetActiveDOMObjectMap().get(imp) :
+                                      GetDOMObjectMap().get(imp);
   if (result.IsEmpty()) {
     v8::Local<v8::Object> v8obj = InstantiateV8Object(type, type, imp);
     if (!v8obj.IsEmpty()) {
       // Go through big switch statement, it has some duplications
       // that were handled by code above (such as CSSVALUE, CSSRULE, etc).
       switch (type) {
 #define MAKE_CASE(TYPE, NAME) \
         case V8ClassIndex::TYPE: static_cast<NAME*>(imp)->ref(); break;
         DOM_OBJECT_TYPES(MAKE_CASE)
 #undef MAKE_CASE
@@ skipping 449 matching lines @@
 #undef FOR_EACH_TAG
 
 #endif  // ENABLE(SVG)
 
 
 v8::Handle<v8::Value> V8Proxy::EventToV8Object(Event* event)
 {
   if (!event)
       return v8::Null();
 
-  v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(event);
+  v8::Handle<v8::Object> wrapper = GetDOMObjectMap().get(event);
   if (!wrapper.IsEmpty())
     return wrapper;
 
   V8ClassIndex::V8WrapperType type = V8ClassIndex::EVENT;
 
   if (event->isUIEvent()) {
     if (event->isKeyboardEvent())
       type = V8ClassIndex::KEYBOARDEVENT;
     else if (event->isTextEvent())
       type = V8ClassIndex::TEXTEVENT;
@@ skipping 38 matching lines @@
 
   return result;
 }
 
 
 // Caller checks node is not null.
 v8::Handle<v8::Value> V8Proxy::NodeToV8Object(Node* node)
 {
   if (!node) return v8::Null();
 
-  v8::Handle<v8::Object> wrapper = getDOMNodeMap().get(node);
+  v8::Handle<v8::Object> wrapper = GetDOMNodeMap().get(node);
   if (!wrapper.IsEmpty())
     return wrapper;
 
   bool is_document = false;  // document type node has special handling
   V8ClassIndex::V8WrapperType type;
 
   switch (node->nodeType()) {
     case Node::ELEMENT_NODE:
       if (node->isHTMLElement())
         type = GetHTMLElementType(static_cast<HTMLElement*>(node));
@@ skipping 125 matching lines @@
       return ToV8Object(V8ClassIndex::WORKER, worker);
 #endif  // WORKERS
 
   Node* node = target->toNode();
   if (node)
       return NodeToV8Object(node);
 
   // XMLHttpRequest is created within its JS counterpart.
   XMLHttpRequest* xhr = target->toXMLHttpRequest();
   if (xhr) {
-    v8::Handle<v8::Object> wrapper = getActiveDOMObjectMap().get(xhr);
+    v8::Handle<v8::Object> wrapper = GetActiveDOMObjectMap().get(xhr);
     ASSERT(!wrapper.IsEmpty());
     return wrapper;
   }
 
   // MessagePort is created within its JS counterpart
   MessagePort* port = target->toMessagePort();
   if (port) {
-    v8::Handle<v8::Object> wrapper = getActiveDOMObjectMap().get(port);
+    v8::Handle<v8::Object> wrapper = GetActiveDOMObjectMap().get(port);
     ASSERT(!wrapper.IsEmpty());
     return wrapper;
   }
 
   XMLHttpRequestUpload* upload = target->toXMLHttpRequestUpload();
   if (upload) {
-    v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(upload);
+    v8::Handle<v8::Object> wrapper = GetDOMObjectMap().get(upload);
     ASSERT(!wrapper.IsEmpty());
     return wrapper;
   }
 
   ASSERT(0);
   return v8::Handle<v8::Value>();
 }
 
 
 v8::Handle<v8::Value> V8Proxy::EventListenerToV8Object(
@@ skipping 21 matching lines @@
     return v8::Null();
   }
   return result;
 }
 
 
 v8::Handle<v8::Value> V8Proxy::StyleSheetToV8Object(StyleSheet* sheet)
 {
   if (!sheet) return v8::Null();
 
-  v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(sheet);
+  v8::Handle<v8::Object> wrapper = GetDOMObjectMap().get(sheet);
   if (!wrapper.IsEmpty())
     return wrapper;
 
   V8ClassIndex::V8WrapperType type = V8ClassIndex::STYLESHEET;
   if (sheet->isCSSStyleSheet())
     type = V8ClassIndex::CSSSTYLESHEET;
 
   v8::Handle<v8::Object> result =
       InstantiateV8Object(type, V8ClassIndex::STYLESHEET, sheet);
   if (!result.IsEmpty()) {
@@ skipping 11 matching lines @@
   }
 
   return result;
 }
 
 
 v8::Handle<v8::Value> V8Proxy::CSSValueToV8Object(CSSValue* value)
 {
   if (!value) return v8::Null();
 
-  v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(value);
+  v8::Handle<v8::Object> wrapper = GetDOMObjectMap().get(value);
   if (!wrapper.IsEmpty())
     return wrapper;
 
   V8ClassIndex::V8WrapperType type;
 
   if (value->isWebKitCSSTransformValue())
     type = V8ClassIndex::WEBKITCSSTRANSFORMVALUE;
   else if (value->isValueList())
     type = V8ClassIndex::CSSVALUELIST;
   else if (value->isPrimitiveValue())
@@ skipping 16 matching lines @@
   }
 
   return result;
 }
 
 
 v8::Handle<v8::Value> V8Proxy::CSSRuleToV8Object(CSSRule* rule)
 {
     if (!rule) return v8::Null();
 
-    v8::Handle<v8::Object> wrapper = getDOMObjectMap().get(rule);
+    v8::Handle<v8::Object> wrapper = GetDOMObjectMap().get(rule);
     if (!wrapper.IsEmpty())
         return wrapper;
 
     V8ClassIndex::V8WrapperType type;
 
     switch (rule->type()) {
         case CSSRule::STYLE_RULE:
             type = V8ClassIndex::CSSSTYLERULE;
             break;
         case CSSRule::CHARSET_RULE:
@@ skipping 163 matching lines @@
 }
 
 void V8Proxy::RegisterExtension(v8::Extension* extension,
                                 const String& schemeRestriction) {
     v8::RegisterExtension(extension);
     V8ExtensionInfo info = {schemeRestriction, extension};
     m_extensions.push_back(info);
 }
 
 }  // namespace WebCore