Use STLPort instead of our stripped version.

This fixes the simulator build and allows us to get closer to sharing code with
chromium.

STLPort was copied with minor edits from the Android port of gears.

6 files changed, 2303 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/pointers/_deque.h b/WebKit/android/stlport/stl/pointers/_deque.h
new file mode 100644
index 0000000..a2c2774
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_deque.h
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_DEQUE_H
+#define _STLP_SPECIALIZED_DEQUE_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#  include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*
+ * struct helper to cast deque iterators:
+ */
+template <class _StorageT, class _ValueT>
+struct _DequeIteCast {
+  typedef _Deque_iterator<_ValueT, _Nonconst_traits<_ValueT> > iterator;
+  typedef _Deque_iterator<_ValueT, _Const_traits<_ValueT> >    const_iterator;
+  typedef _Deque_iterator<_StorageT, _Nonconst_traits<_StorageT> > storage_iterator;
+  typedef _Deque_iterator<_StorageT, _Const_traits<_StorageT> > const_storage_iterator;
+  typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+  static iterator to_value_type_ite (storage_iterator const& __ite) {
+    iterator tmp;
+    tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur);
+    tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first);
+    tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last);
+    tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node);
+    return tmp;
+  }
+  static storage_iterator to_storage_type_ite (iterator const& __ite) {
+    storage_iterator tmp;
+    tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur);
+    tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first);
+    tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last);
+    tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node);
+    return tmp;
+  }
+
+  static const_iterator to_value_type_cite (const_storage_iterator const& __ite) {
+    const_iterator tmp;
+    tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur);
+    tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first);
+    tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last);
+    tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node);
+    return tmp;
+  }
+
+  static const_storage_iterator to_storage_type_cite (const_iterator const& __ite) {
+    const_storage_iterator tmp;
+    tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur);
+    tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first);
+    tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last);
+    tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node);
+    return tmp;
+  }
+};
+
+#define DEQUE_IMPL _STLP_PTR_IMPL_NAME(deque)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<size_t, void*,  allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void***, void**,  allocator<void**> >;
+_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC _Deque_iterator<void*, _Nonconst_traits<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Deque_base<void*,allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS DEQUE_IMPL<void*,allocator<void*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
+class deque
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque)
+            : public __stlport_class<deque<_Tp, _Alloc> >
+#endif
+{
+  typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+  typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV DEQUE_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+  typedef deque<_Tp, _Alloc> _Self;
+
+  typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+  typedef _STLP_PRIV _DequeIteCast<_StorageType, _Tp> ite_cast_traits;
+
+public:
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef random_access_iterator_tag _Iterator_category;
+  _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+  typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+  typedef _STLP_PRIV _Deque_iterator<value_type, _Nonconst_traits<value_type> > iterator;
+  typedef _STLP_PRIV _Deque_iterator<value_type, _Const_traits<value_type> >    const_iterator;
+
+  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+public:                         // Basic accessors
+  iterator begin() { return ite_cast_traits::to_value_type_ite(_M_impl.begin()); }
+  iterator end()   { return ite_cast_traits::to_value_type_ite(_M_impl.end()); }
+  const_iterator begin() const { return ite_cast_traits::to_value_type_cite(_M_impl.begin()); }
+  const_iterator end() const   { return ite_cast_traits::to_value_type_cite(_M_impl.end()); }
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  reverse_iterator rend()   { return reverse_iterator(begin()); }
+  const_reverse_iterator rbegin() const
+  { return const_reverse_iterator(end()); }
+  const_reverse_iterator rend() const
+  { return const_reverse_iterator(begin()); }
+
+  reference operator[](size_type __n)
+  { return cast_traits::to_value_type_ref(_M_impl[__n]); }
+  const_reference operator[](size_type __n) const
+  { return cast_traits::to_value_type_cref(_M_impl[__n]); }
+
+  reference at(size_type __n)
+  { return cast_traits::to_value_type_ref(_M_impl.at(__n)); }
+  const_reference at(size_type __n) const
+  { return cast_traits::to_value_type_cref(_M_impl.at(__n)); }
+
+  reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); }
+  reference back()  { return cast_traits::to_value_type_ref(_M_impl.back()); }
+  const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); }
+  const_reference back() const  { return cast_traits::to_value_type_cref(_M_impl.back()); }
+
+  size_type size() const     { return _M_impl.size(); }
+  size_type max_size() const { return _M_impl.max_size(); }
+  bool empty() const         { return _M_impl.empty(); }
+  allocator_type get_allocator() const { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+  explicit deque(const allocator_type& __a = allocator_type())
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+  deque(const _Self& __x) : _M_impl(__x._M_impl) {}
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit deque(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+  deque(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+        const allocator_type& __a = allocator_type())
+    : _M_impl(__n, cast_traits::to_storage_type_cref(__val), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+  // int,long variants may be needed
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit deque(size_type __n) : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  deque(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+#if !defined (_STLP_USE_ITERATOR_WRAPPER)
+  : _M_impl(__first, __last,
+            _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+#else
+  : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+#endif
+#if defined (_STLP_USE_ITERATOR_WRAPPER)
+    insert(end(), __first, __last);
+#endif
+  }
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  deque(_InputIterator __first, _InputIterator __last)
+#    if !defined (_STLP_USE_ITERATOR_WRAPPER)
+    : _M_impl(__first, __last) {}
+#    else
+  { insert(end(), __first, __last); }
+#    endif
+#  endif
+
+#else
+  deque(const_pointer __first, const_pointer __last,
+        const allocator_type& __a = allocator_type() )
+    : _M_impl(cast_traits::to_storage_type_cptr(__first),
+              cast_traits::to_storage_type_cptr(__last),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+  deque(const_iterator __first, const_iterator __last,
+        const allocator_type& __a = allocator_type() )
+    : _M_impl(ite_cast_traits::to_storage_type_cite(__first),
+              ite_cast_traits::to_storage_type_cite(__last),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  deque(__move_source<_Self> src)
+    : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+
+  _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+  void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+
+  void assign(size_type __n, const value_type& __val) {
+    _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val));
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val,
+                          const __true_type&)
+  { _M_impl.assign(__n, __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+#  else
+    _M_impl.assign(__first, __last);
+#  endif
+  }
+#else
+  void assign(const_pointer __first, const_pointer __last)
+  { _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+                   cast_traits::to_storage_type_cptr(__last)); }
+  void assign(const_iterator __first, const_iterator __last)
+  { _M_impl.assign(ite_cast_traits::to_storage_type_cite(__first),
+                   ite_cast_traits::to_storage_type_cite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void push_back(const value_type& __t)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { _M_impl.push_back(cast_traits::to_storage_type_cref(__t)); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void push_front(const value_type& __t)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { _M_impl.push_front(cast_traits::to_storage_type_cref(__t)); }
+
+# if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  void push_back()  { _M_impl.push_back(); }
+  void push_front() { _M_impl.push_front(); }
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void pop_back()  { _M_impl.pop_back(); }
+  void pop_front() { _M_impl.pop_front(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  iterator insert(iterator __pos, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { return ite_cast_traits::to_value_type_ite(_M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+                                                             cast_traits::to_storage_type_cref(__x))); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void insert(iterator __pos, size_type __n, const value_type& __x)
+  { _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+                          const __true_type&) {
+    _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, __val);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    // Check whether it's an integral type.  If so, it's not an iterator.
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+#  else
+    _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __first, __last);
+#  endif
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert(iterator __pos,
+              const_pointer __first, const_pointer __last) {
+    _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+                   cast_traits::to_storage_type_cptr(__first),
+                   cast_traits::to_storage_type_cptr(__last));
+  }
+  void insert(iterator __pos,
+              const_iterator __first, const_iterator __last) {
+    _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+                   ite_cast_traits::to_storage_type_cite(__first),
+                   ite_cast_traits::to_storage_type_cite(__last));
+  }
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+  { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  iterator erase(iterator __pos)
+  { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__pos))); }
+
+  iterator erase(iterator __first, iterator __last)
+  { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__first),
+                                                            ite_cast_traits::to_storage_type_ite(__last))); }
+  void clear() { _M_impl.clear(); }
+
+private:
+  _Base _M_impl;
+};
+
+#if defined (deque)
+#  undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef DEQUE_IMPL
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stlport/stl/pointers/_list.h b/WebKit/android/stlport/stl/pointers/_list.h
new file mode 100644
index 0000000..441b11d
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_list.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_PTR_SPECIALIZED_LIST_H
+#define _STLP_PTR_SPECIALIZED_LIST_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#  include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define LIST_IMPL _STLP_PTR_IMPL_NAME(list)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _List_node<void*>;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS allocator<_STLP_PRIV _List_node<void*> >;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_List_node_base, _List_node<void*>, allocator<_List_node<void*> > >;
+_STLP_EXPORT_TEMPLATE_CLASS _List_base<void*, allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS LIST_IMPL<void*, allocator<void*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define list _STLP_NON_DBG_NAME(list)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
+class list
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (list)
+           : public __stlport_class<list<_Tp, _Alloc> >
+#endif
+{
+  typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+  typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV LIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+  typedef typename _Base::iterator _BaseIte;
+  typedef typename _Base::const_iterator _BaseConstIte;
+  typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+  typedef list<_Tp, _Alloc> _Self;
+
+public:
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+  typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+  typedef bidirectional_iterator_tag _Iterator_category;
+
+  typedef _STLP_PRIV _List_iterator<value_type, _Nonconst_traits<value_type> > iterator;
+  typedef _STLP_PRIV _List_iterator<value_type, _Const_traits<value_type> >    const_iterator;
+
+  _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+# if !(defined(__MRC__)||(defined(__SC__) && !defined(__DMC__)))
+  explicit
+# endif
+  list(const allocator_type& __a = allocator_type())
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit list(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+  list(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+       const allocator_type& __a = allocator_type())
+    : _M_impl(__n, cast_traits::to_storage_type_cref(__val),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit list(size_type __n)
+    : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  list(_InputIterator __first, _InputIterator __last,
+       const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+#  if !defined (_STLP_USE_ITERATOR_WRAPPER)
+    : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#  else
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+    insert(begin(), __first, __last);
+  }
+#  endif
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  list(_InputIterator __first, _InputIterator __last)
+#    if !defined (_STLP_USE_WRAPPER_ITERATOR)
+    : _M_impl(__first, __last) {}
+#    else
+  { insert(begin(), __first, __last); }
+#    endif
+#  endif
+
+#else /* _STLP_MEMBER_TEMPLATES */
+
+  list(const value_type *__first, const value_type *__last,
+       const allocator_type& __a = allocator_type())
+    : _M_impl(cast_traits::to_storage_type_cptr(__first),
+              cast_traits::to_storage_type_cptr(__last),
+               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+  list(const_iterator __first, const_iterator __last,
+       const allocator_type& __a = allocator_type())
+    : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  list(const _Self& __x) : _M_impl(__x._M_impl) {}
+
+  list(__move_source<_Self> src)
+    : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+
+  iterator begin()             { return iterator(_M_impl.begin()._M_node); }
+  const_iterator begin() const { return const_iterator(_M_impl.begin()._M_node); }
+
+  iterator end()               { return iterator(_M_impl.end()._M_node); }
+  const_iterator end() const   { return const_iterator(_M_impl.end()._M_node); }
+
+  reverse_iterator rbegin()             { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+
+  reverse_iterator rend()               { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const   { return const_reverse_iterator(begin()); }
+
+  bool empty() const         { return _M_impl.empty(); }
+  size_type size() const     { return _M_impl.size(); }
+  size_type max_size() const { return _M_impl.max_size(); }
+
+  reference front()             { return *begin(); }
+  const_reference front() const { return *begin(); }
+  reference back()              { return *(--end()); }
+  const_reference back() const  { return *(--end()); }
+
+  void swap(_Self &__x) { _M_impl.swap(__x._M_impl); }
+  void clear() { _M_impl.clear(); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos, const_reference __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  iterator insert(iterator __pos, const_reference __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
+                                   cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+                          const __true_type&)
+  { _M_impl.insert(_BaseIte(__pos._M_node), __n, __val); }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.insert(_BaseIte(__pos._M_node),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    // Check whether it's an integral type.  If so, it's not an iterator.
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+#  else
+    _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
+#  endif
+  }
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert(iterator __pos, const value_type *__first, const value_type *__last)
+  { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
+                                            cast_traits::to_storage_type_cptr(__last)); }
+  void insert(iterator __pos, const_iterator __first, const_iterator __last)
+  { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  void insert(iterator __pos, size_type __n, const value_type& __x)
+  { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+  void push_front(const value_type& __x) { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
+  void push_back(const value_type& __x)  { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos) { return iterator(_M_impl.insert(__pos._M_node)._M_node); }
+  void push_front() { _M_impl.push_front();}
+  void push_back()  { _M_impl.push_back();}
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  iterator erase(iterator __pos)
+  { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
+  iterator erase(iterator __first, iterator __last)
+  { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+  void resize(size_type __new_size, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM*/
+  {_M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
+
+  void pop_front() { _M_impl.pop_front(); }
+  void pop_back()  { _M_impl.pop_back(); }
+
+  _Self& operator=(const _Self& __x)
+  { _M_impl = __x._M_impl; return *this; }
+  void assign(size_type __n, const value_type& __val)
+  { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&)
+  { _M_impl.assign(__n, __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+#  else
+    _M_impl.assign(__first, __last);
+#  endif
+  }
+#else
+  void assign(const value_type *__first, const value_type *__last) {
+    _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+                   cast_traits::to_storage_type_cptr(__last));
+  }
+  void assign(const_iterator __first, const_iterator __last)
+  { _M_impl.assign(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+#endif
+
+  void splice(iterator __pos, _Self& __x)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
+  void splice(iterator __pos, _Self& __x, iterator __i)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
+  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
+                   _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
+
+  void remove(const_reference __val)
+  { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
+  void unique() { _M_impl.unique(); }
+  void merge(_Self& __x) { _M_impl.merge(__x._M_impl); }
+  void reverse() { _M_impl.reverse(); }
+  void sort() { _M_impl.sort(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _Predicate>
+  void remove_if(_Predicate __pred)
+  { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
+  template <class _BinaryPredicate>
+  void unique(_BinaryPredicate __bin_pred)
+  { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__bin_pred)); }
+
+  template <class _StrictWeakOrdering>
+  void merge(_Self &__x, _StrictWeakOrdering __comp)
+  { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+
+  template <class _StrictWeakOrdering>
+  void sort(_StrictWeakOrdering __comp)
+  { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+private:
+  _Base _M_impl;
+};
+
+#if defined (list)
+#  undef list
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef LIST_IMPL
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_PTR_SPECIALIZED_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stlport/stl/pointers/_set.h b/WebKit/android/stlport/stl/pointers/_set.h
new file mode 100644
index 0000000..c66fd98
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_set.h
@@ -0,0 +1,536 @@
+/*
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_PTR_SPECIALIZED_SET_H
+#define _STLP_PTR_SPECIALIZED_SET_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#  include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(SetTraitsT, Const_traits)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC less<void*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+typedef _Rb_tree_node<void*> _Node;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Rb_tree_node_base, _Node,  allocator<_Node> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree_base<void*, allocator<void*> >;
+#  if defined (_STLP_DEBUG)
+_STLP_EXPORT_TEMPLATE_CLASS _DbgCompare<void*, less<void*> >;
+#    define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree)
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, _DbgCompare<void*, less<void*> >, void*, _Identity<void*>,
+                                     _SetTraitsT<void*>, allocator<void*> >;
+#    undef _Rb_tree
+#  endif
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, less<void*>, void*, _Identity<void*>,
+                                     _SetTraitsT<void*>, allocator<void*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+                      _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) >
+class set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+          : public __stlport_class<set<_Key, _Compare, _Alloc> >
+#endif
+{
+  typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
+  typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
+  typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
+  typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
+
+  typedef set<_Key, _Compare, _Alloc> _Self;
+public:
+  typedef _Key     key_type;
+  typedef _Key     value_type;
+  typedef _Compare key_compare;
+  typedef _Compare value_compare;
+
+protected:
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _SetTraitsT<value_type> _SetTraits;
+  typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+                              value_type, _STLP_PRIV _Identity<value_type>,
+                              _SetTraits, _Alloc> _Priv_Rep_type;
+
+  typedef _STLP_PRIV _SetTraitsT<_KeyStorageType> _SetStorageTraits;
+
+public:
+  //dums: need the following public for the __move_traits framework
+  typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
+                              _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
+                              _SetStorageTraits, _StorageTypeAlloc> _Rep_type;
+
+private:
+  typedef typename _Rep_type::iterator base_iterator;
+  typedef typename _Rep_type::const_iterator const_base_iterator;
+
+public:
+  typedef typename _Priv_Rep_type::pointer pointer;
+  typedef typename _Priv_Rep_type::const_pointer const_pointer;
+  typedef typename _Priv_Rep_type::reference reference;
+  typedef typename _Priv_Rep_type::const_reference const_reference;
+  typedef typename _Priv_Rep_type::iterator iterator;
+  typedef typename _Priv_Rep_type::const_iterator const_iterator;
+  typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
+  typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Priv_Rep_type::size_type size_type;
+  typedef typename _Priv_Rep_type::difference_type difference_type;
+  typedef typename _Priv_Rep_type::allocator_type allocator_type;
+
+private:
+  _Rep_type _M_t;  // red-black tree representing set
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+#if defined (_STLP_DEBUG)
+  static iterator _S_to_value_ite(const_base_iterator __ite)
+  { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+  static base_iterator _S_to_storage_ite(const_iterator __ite)
+  { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+#else
+  static iterator _S_to_value_ite(const_base_iterator __ite)
+  { return iterator(__ite._M_node); }
+  static base_iterator _S_to_storage_ite(const_iterator __ite)
+  { return base_iterator(__ite._M_node); }
+#endif
+
+public:
+  set() : _M_t(_CompareStorageType(), _StorageTypeAlloc()) {}
+  explicit set(const _Compare& __comp,
+               const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  set(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), _StorageTypeAlloc()) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_unique(__first, __last);
+#  endif
+  }
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp)
+    : _M_t(__comp, _StorageTypeAlloc()) {
+#    if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#    else
+    _M_t.insert_unique(__first, __last);
+#    endif
+  }
+#  endif
+  template <class _InputIterator>
+  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+      const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_unique(__first, __last);
+#  endif
+  }
+#else
+  set(const value_type* __first, const value_type* __last)
+    : _M_t(_Compare(), _StorageTypeAlloc()) {
+    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+                       cast_traits::to_storage_type_cptr(__last));
+  }
+
+  set(const value_type* __first, const value_type* __last,
+      const _Compare& __comp, const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+                       cast_traits::to_storage_type_cptr(__last));
+  }
+
+  set(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), _StorageTypeAlloc())
+  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+
+  set(const_iterator __first, const_iterator __last,
+      const _Compare& __comp, const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
+  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  set(const _Self& __x) : _M_t(__x._M_t) {}
+
+  set(__move_source<_Self> src)
+    : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+
+  _Self& operator=(const _Self& __x) {
+    _M_t = __x._M_t;
+    return *this;
+  }
+
+  // accessors:
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return _M_t.key_comp(); }
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
+
+  iterator begin() { return _S_to_value_ite(_M_t.begin()); }
+  iterator end() { return _S_to_value_ite(_M_t.end()); }
+  const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
+  const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+  pair<iterator,bool> insert(const value_type& __x) {
+    pair<base_iterator, bool> ret = _M_t.insert_unique(cast_traits::to_storage_type_cref(__x));
+    return pair<iterator, bool>(_S_to_value_ite(ret.first), ret.second);
+  }
+  iterator insert(iterator __pos, const value_type& __x)
+  { return _S_to_value_ite(_M_t.insert_unique(_S_to_storage_ite(__pos), cast_traits::to_storage_type_cref(__x))); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_unique(__first, __last);
+#  endif
+  }
+#else
+  void insert(const_iterator __first, const_iterator __last)
+  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+                       cast_traits::to_storage_type_cptr(__last));
+  }
+#endif
+  void erase(iterator __pos)
+  { _M_t.erase(_S_to_storage_ite(__pos)); }
+  size_type erase(const key_type& __x)
+  { return _M_t.erase_unique(cast_traits::to_storage_type_cref(__x)); }
+  void erase(iterator __first, iterator __last)
+  { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+  void clear() { _M_t.clear(); }
+
+  // set operations:
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __x)
+  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __x) const
+  { return _M_t.find(cast_traits::to_storage_type_crefT(__x)) == _M_t.end() ? 0 : 1; }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator lower_bound(const _KT& __x)
+  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator lower_bound(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator upper_bound(const _KT& __x)
+  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator upper_bound(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __x) {
+    pair<base_iterator, base_iterator> __ret;
+    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+    return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
+                                    _S_to_value_ite(__ret.second));
+  }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
+    pair<const_base_iterator, const_base_iterator> __ret;
+    __ret = _M_t.equal_range_unique(cast_traits::to_storage_type_crefT(__x));
+    return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
+                                                _S_to_value_ite(__ret.second));
+  }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(MultisetTraitsT, Const_traits)
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+                     _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) >
+class multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+               : public __stlport_class<multiset<_Key, _Compare, _Alloc> >
+#endif
+{
+  typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
+  typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
+  typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
+  typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
+
+  typedef multiset<_Key, _Compare, _Alloc> _Self;
+public:
+  // typedefs:
+  typedef _Key     key_type;
+  typedef _Key     value_type;
+  typedef _Compare key_compare;
+  typedef _Compare value_compare;
+
+protected:
+  //Specific iterator traits creation
+  typedef _STLP_PRIV _MultisetTraitsT<value_type> _MultisetTraits;
+  typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+                              value_type, _STLP_PRIV _Identity<value_type>,
+                              _MultisetTraits, _Alloc> _Priv_Rep_type;
+
+  typedef _STLP_PRIV _MultisetTraitsT<_KeyStorageType> _MultisetStorageTraits;
+public:
+  //dums: need the following public for the __move_traits framework
+  typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
+                              _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
+                              _MultisetStorageTraits, _StorageTypeAlloc> _Rep_type;
+
+private:
+  typedef typename _Rep_type::iterator base_iterator;
+  typedef typename _Rep_type::const_iterator const_base_iterator;
+
+public:
+  typedef typename _Priv_Rep_type::pointer pointer;
+  typedef typename _Priv_Rep_type::const_pointer const_pointer;
+  typedef typename _Priv_Rep_type::reference reference;
+  typedef typename _Priv_Rep_type::const_reference const_reference;
+  typedef typename _Priv_Rep_type::iterator iterator;
+  typedef typename _Priv_Rep_type::const_iterator const_iterator;
+  typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
+  typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
+  typedef typename _Priv_Rep_type::size_type size_type;
+  typedef typename _Priv_Rep_type::difference_type difference_type;
+  typedef typename _Priv_Rep_type::allocator_type allocator_type;
+
+private:
+  _Rep_type _M_t;  // red-black tree representing multiset
+  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+#if defined (_STLP_DEBUG)
+  static iterator _S_to_value_ite(const_base_iterator __ite)
+  { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+  static base_iterator _S_to_storage_ite(const_iterator __ite)
+  { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+#else
+  static iterator _S_to_value_ite(const_base_iterator __ite)
+  { return iterator(__ite._M_node); }
+  static base_iterator _S_to_storage_ite(const_iterator __ite)
+  { return base_iterator(__ite._M_node); }
+#endif
+
+public:
+  multiset() : _M_t(_Compare(), _StorageTypeAlloc()) {}
+  explicit multiset(const _Compare& __comp,
+                    const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  multiset(_InputIterator __first, _InputIterator __last)
+    : _M_t(_Compare(), _StorageTypeAlloc()) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_equal(__first, __last);
+#  endif
+  }
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  multiset(_InputIterator __first, _InputIterator __last,
+           const _Compare& __comp)
+    : _M_t(__comp, _StorageTypeAlloc()) {
+#    if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#    else
+    _M_t.insert_equal(__first, __last);
+#    endif
+  }
+#  endif
+  template <class _InputIterator>
+  multiset(_InputIterator __first, _InputIterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_equal(__first, __last);
+#  endif
+  }
+
+#else
+  multiset(const value_type* __first, const value_type* __last)
+    : _M_t(_Compare(), _StorageTypeAlloc()) {
+    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+                      cast_traits::to_storage_type_cptr(__last));
+  }
+
+  multiset(const value_type* __first, const value_type* __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+                      cast_traits::to_storage_type_cptr(__last));
+  }
+
+  multiset(const_iterator __first, const_iterator __last)
+    : _M_t(_Compare(), _StorageTypeAlloc())
+  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+
+  multiset(const_iterator __first, const_iterator __last,
+           const _Compare& __comp,
+           const allocator_type& __a = allocator_type())
+    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
+  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  multiset(const _Self& __x)
+    : _M_t(__x._M_t) {}
+
+  _Self& operator=(const _Self& __x) {
+    _M_t = __x._M_t;
+    return *this;
+  }
+
+  multiset(__move_source<_Self> src)
+    : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+
+  // accessors:
+  key_compare key_comp() const { return _M_t.key_comp(); }
+  value_compare value_comp() const { return _M_t.key_comp(); }
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
+
+  iterator begin() { return _S_to_value_ite(_M_t.begin()); }
+  iterator end() { return _S_to_value_ite(_M_t.end()); }
+  const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
+  const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  bool empty() const { return _M_t.empty(); }
+  size_type size() const { return _M_t.size(); }
+  size_type max_size() const { return _M_t.max_size(); }
+  void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+
+  // insert/erase
+  iterator insert(const value_type& __x)
+  { return _S_to_value_ite(_M_t.insert_equal(cast_traits::to_storage_type_cref(__x))); }
+  iterator insert(iterator __pos, const value_type& __x) {
+    return _S_to_value_ite(_M_t.insert_equal(_S_to_storage_ite(__pos),
+                                             cast_traits::to_storage_type_cref(__x)));
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void insert(_InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+#  else
+    _M_t.insert_equal(__first, __last);
+#  endif
+  }
+#else
+  void insert(const value_type* __first, const value_type* __last) {
+    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+                      cast_traits::to_storage_type_cptr(__last));
+  }
+  void insert(const_iterator __first, const_iterator __last)
+  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  void erase(iterator __pos)
+  { _M_t.erase(_S_to_storage_ite(__pos)); }
+  size_type erase(const key_type& __x)
+  { return _M_t.erase(cast_traits::to_storage_type_cref(__x)); }
+  void erase(iterator __first, iterator __last)
+  { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+  void clear() { _M_t.clear(); }
+
+  // multiset operations:
+
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator find(const _KT& __x)
+  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator find(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  size_type count(const _KT& __x) const
+  { return _M_t.count(cast_traits::to_storage_type_crefT(__x)); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator lower_bound(const _KT& __x)
+  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator lower_bound(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  iterator upper_bound(const _KT& __x)
+  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  const_iterator upper_bound(const _KT& __x) const
+  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<iterator, iterator> equal_range(const _KT& __x) {
+    pair<base_iterator, base_iterator> __ret;
+    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+    return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
+                                    _S_to_value_ite(__ret.second));
+  }
+  _STLP_TEMPLATE_FOR_CONT_EXT
+  pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
+    pair<const_base_iterator, const_base_iterator> __ret;
+    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+    return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
+                                                _S_to_value_ite(__ret.second));
+  }
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_PTR_SPECIALIZED_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stlport/stl/pointers/_slist.h b/WebKit/android/stlport/stl/pointers/_slist.h
new file mode 100644
index 0000000..93ff211
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_slist.h
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_SLIST_H
+#define _STLP_SPECIALIZED_SLIST_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#  include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define SLIST_IMPL _STLP_PTR_IMPL_NAME(slist)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _Slist_node<void*>;
+typedef _Slist_node<void*> _VoidPtrSNode;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base, _VoidPtrSNode, allocator<_VoidPtrSNode> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Slist_base<void*, allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS SLIST_IMPL<void*, allocator<void*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define slist _STLP_NON_DBG_NAME(slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
+class slist
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
+             : public __stlport_class<slist<_Tp, _Alloc> >
+#endif
+{
+  typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+  typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV SLIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+  typedef typename _Base::iterator _BaseIte;
+  typedef typename _Base::const_iterator _BaseConstIte;
+  typedef slist<_Tp, _Alloc> _Self;
+  typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+  typedef _STLP_PRIV _Slist_node_base _Node_base;
+
+public:
+  typedef _Tp               value_type;
+  typedef value_type*       pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type&       reference;
+  typedef const value_type& const_reference;
+  typedef size_t            size_type;
+  typedef ptrdiff_t         difference_type;
+  typedef forward_iterator_tag _Iterator_category;
+
+  typedef _STLP_PRIV _Slist_iterator<value_type, _Nonconst_traits<value_type> >  iterator;
+  typedef _STLP_PRIV _Slist_iterator<value_type, _Const_traits<value_type> >     const_iterator;
+
+  _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+  typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+
+public:
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+  explicit slist(const allocator_type& __a = allocator_type())
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+  slist(size_type __n, const value_type& __x,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+        const allocator_type& __a =  allocator_type())
+    : _M_impl(__n, cast_traits::to_storage_type_cref(__x), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit slist(size_type __n) : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  // We don't need any dispatching tricks here, because _M_insert_after_range
+  // already does them.
+  template <class _InputIterator>
+  slist(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+#  if !defined (_STLP_USE_ITERATOR_WRAPPER)
+    : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#  else
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+    insert_after(before_begin(), __first, __last);
+  }
+#  endif
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  // VC++ needs this crazyness
+  template <class _InputIterator>
+  slist(_InputIterator __first, _InputIterator __last)
+#    if !defined (_STLP_USE_WRAPPER_ITERATOR)
+    : _M_impl(__first, __last) {}
+#    else
+  { insert_after(before_begin(), __first, __last); }
+#    endif
+#  endif
+#else /* _STLP_MEMBER_TEMPLATES */
+  slist(const_iterator __first, const_iterator __last,
+        const allocator_type& __a =  allocator_type() )
+    : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+  slist(const value_type* __first, const value_type* __last,
+        const allocator_type& __a =  allocator_type())
+    : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  slist(const _Self& __x) : _M_impl(__x._M_impl) {}
+  slist(__move_source<_Self> src)
+    : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+
+  _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+  void assign(size_type __n, const value_type& __val)
+  { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_assign_dispatch(_Integer __n, _Integer __val,
+                          const __true_type&)
+  { _M_impl.assign(__n, __val); }
+
+  template <class _InputIterator>
+  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                   typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_assign_dispatch(__first, __last, _Integral());
+#  else
+    _M_impl.assign(__first, __last);
+#  endif
+  }
+#else
+  void assign(const value_type *__first, const value_type *__last) {
+    _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+                   cast_traits::to_storage_type_cptr(__last));
+  }
+  void assign(const_iterator __first, const_iterator __last) {
+    _M_impl.assign(_BaseConstIte(__first._M_node),
+                   _BaseConstIte(__last._M_node));
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  iterator before_begin()             { return iterator(_M_impl.before_begin()._M_node); }
+  const_iterator before_begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.before_begin()._M_node)); }
+
+  iterator begin()                    { return iterator(_M_impl.begin()._M_node); }
+  const_iterator begin() const        { return const_iterator(const_cast<_Node_base*>(_M_impl.begin()._M_node));}
+
+  iterator end()                      { return iterator(_M_impl.end()._M_node); }
+  const_iterator end() const          { return iterator(_M_impl.end()._M_node); }
+
+  size_type size() const      { return _M_impl.size(); }
+  size_type max_size() const  { return _M_impl.max_size(); }
+  bool empty() const          { return _M_impl.empty(); }
+
+  void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+
+public:
+  reference front()             { return *begin(); }
+  const_reference front() const { return *begin(); }
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  void push_front(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void push_front(const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
+
+# if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  void push_front() { _M_impl.push_front();}
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void pop_front() { _M_impl.pop_front(); }
+
+  iterator previous(const_iterator __pos)
+  { return iterator(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node); }
+  const_iterator previous(const_iterator __pos) const
+  { return const_iterator(const_cast<_Node_base*>(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node)); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert_after(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  iterator insert_after(iterator __pos, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+  { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node),
+                                         cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert_after(iterator __pos)
+  { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node))._M_node);}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void insert_after(iterator __pos, size_type __n, const value_type& __x)
+  { _M_impl.insert_after(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_insert_after_dispatch(iterator __pos, _Integer __n, _Integer __val,
+                                const __true_type&) {
+    _M_impl.insert_after(_BaseIte(__pos._M_node), __n, __val);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_after_dispatch(iterator __pos,
+                                _InputIterator __first, _InputIterator __last,
+                                const __false_type&) {
+    _M_impl.insert_after(_BaseIte(__pos._M_node),
+                         typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                         typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void insert_after(iterator __pos, _InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    // Check whether it's an integral type.  If so, it's not an iterator.
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_insert_after_dispatch(__pos, __first, __last, _Integral());
+#  else
+    _M_impl.insert_after(_BaseIte(__pos._M_node), __first, __last);
+#  endif
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert_after(iterator __pos,
+                    const_iterator __first, const_iterator __last)
+  { _M_impl.insert_after(_BaseIte(__pos._M_node),
+                         _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+  void insert_after(iterator __pos,
+                    const value_type* __first, const value_type* __last) {
+    _M_impl.insert_after(_BaseIte(__pos._M_node),
+                         cast_traits::to_storage_type_cptr(__first),
+                         cast_traits::to_storage_type_cptr(__last));
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  iterator insert(iterator __pos, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+  { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
+                                   cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  iterator insert(iterator __pos)
+  { return iterator(_M_impl.insert(_BaseIte(__pos._M_node))._M_node); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void insert(iterator __pos, size_type __n, const value_type& __x)
+  { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+                          const __true_type&) {
+    _M_impl.insert(_BaseIte(__pos._M_node), __n, __val);
+  }
+
+  template <class _InputIterator>
+  void _M_insert_dispatch(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          const __false_type&) {
+    _M_impl.insert(_BaseIte(__pos._M_node), typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+                                            typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+  }
+
+public:
+#  endif
+
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+#  if defined (_STLP_USE_ITERATOR_WRAPPER)
+    // Check whether it's an integral type.  If so, it's not an iterator.
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_insert_dispatch(__pos, __first, __last, _Integral());
+#  else
+    _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
+#  endif
+  }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+  void insert(iterator __pos, const_iterator __first, const_iterator __last)
+  { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+  void insert(iterator __pos, const value_type* __first, const value_type* __last)
+  { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
+                                            cast_traits::to_storage_type_cptr(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  iterator erase_after(iterator __pos)
+  { return iterator(_M_impl.erase_after(_BaseIte(__pos._M_node))._M_node); }
+  iterator erase_after(iterator __before_first, iterator __last)
+  { return iterator(_M_impl.erase_after(_BaseIte(__before_first._M_node),
+                                        _BaseIte(__last._M_node))._M_node); }
+
+  iterator erase(iterator __pos)
+  { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
+  iterator erase(iterator __first, iterator __last)
+  { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+  { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void clear() { _M_impl.clear(); }
+
+  void splice_after(iterator __pos, _Self& __x,
+                    iterator __before_first, iterator __before_last)
+  { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl,
+                         _BaseIte(__before_first._M_node), _BaseIte(__before_last._M_node)); }
+  void splice_after(iterator __pos, _Self& __x, iterator __prev)
+  { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__prev._M_node)); }
+  void splice_after(iterator __pos, _Self& __x)
+  { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl); }
+  void splice(iterator __pos, _Self& __x)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
+  void splice(iterator __pos, _Self& __x, iterator __i)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
+  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
+  { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
+                   _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
+
+  void reverse() { _M_impl.reverse(); }
+
+  void remove(const value_type& __val) { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
+  void unique()                 { _M_impl.unique(); }
+  void merge(_Self& __x)        { _M_impl.merge(__x._M_impl); }
+  void sort()                   {_M_impl.sort(); }
+
+#ifdef _STLP_MEMBER_TEMPLATES
+  template <class _Predicate>
+  void remove_if(_Predicate __pred)
+  { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
+
+  template <class _BinaryPredicate>
+  void unique(_BinaryPredicate __pred)
+  { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__pred)); }
+
+  template <class _StrictWeakOrdering>
+  void merge(_Self& __x, _StrictWeakOrdering __comp)
+  { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+
+  template <class _StrictWeakOrdering>
+  void sort(_StrictWeakOrdering __comp)
+  { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+private:
+  _Base _M_impl;
+};
+
+#if defined (slist)
+#  undef slist
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef SLIST_IMPL
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stlport/stl/pointers/_tools.h b/WebKit/android/stlport/stl/pointers/_tools.h
new file mode 100644
index 0000000..e02fc42
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_tools.h
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#define _STLP_POINTERS_SPEC_TOOLS_H
+
+#ifndef _STLP_TYPE_TRAITS_H
+#  include <stl/type_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Some usefull declarations:
+template <class _Tp> struct less;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _StorageT, class _ValueT, class _BinaryPredicate>
+struct _BinaryPredWrapper;
+
+/*
+ * Since the compiler only allows at most one non-trivial
+ * implicit conversion we can make use of a shim class to
+ * be sure that functions below doesn't accept classes with
+ * implicit pointer conversion operators
+ */
+struct _ConstVolatileVoidPointerShim
+{ _ConstVolatileVoidPointerShim(const volatile void*); };
+
+//The dispatch functions:
+struct _VoidPointerShim
+{ _VoidPointerShim(void*); };
+struct _ConstVoidPointerShim
+{ _ConstVoidPointerShim(const void*); };
+struct _VolatileVoidPointerShim
+{ _VolatileVoidPointerShim(volatile void*); };
+
+template <class _Tp>
+char _UseVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseVoidPtrStorageType(const __true_type& /*POD*/, _VoidPointerShim);
+
+template <class _Tp>
+char _UseConstVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseConstVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseConstVoidPtrStorageType(const __true_type& /*POD*/, _ConstVoidPointerShim);
+
+template <class _Tp>
+char _UseVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, _VolatileVoidPointerShim);
+
+template <class _Tp>
+char _UseConstVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, _ConstVolatileVoidPointerShim);
+
+template <class _Tp>
+struct _StorageType {
+  typedef typename __type_traits<_Tp>::is_POD_type _PODType;
+  static _Tp __null_rep();
+
+  enum { use_void_ptr = (sizeof(_UseVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+  enum { use_const_void_ptr = (sizeof(_UseConstVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+  enum { use_volatile_void_ptr = (sizeof(_UseVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+  enum { use_const_volatile_void_ptr = (sizeof(_UseConstVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+
+  typedef typename __select<!use_const_volatile_void_ptr,
+                            _Tp,
+          typename __select<use_void_ptr,
+                            void*,
+          typename __select<use_const_void_ptr,
+                            const void*,
+          typename __select<use_volatile_void_ptr,
+                            volatile void*,
+                            const volatile void*>::_Ret >::_Ret >::_Ret >::_Ret _QualifiedType;
+
+#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+  /* If the compiler do not support the iterator_traits structure we cannot wrap
+   * iterators pass to container template methods. The iterator dereferenced value
+   * has to be storable without any cast in the chosen storage type. To guaranty
+   * that the void pointer has to be correctly qualified.
+   */
+  typedef _QualifiedType _Type;
+#else
+  /* With iterator_traits we can wrap passed iterators and make the necessary casts.
+   * We can always use a simple void* storage type:
+   */
+  typedef typename __select<use_const_volatile_void_ptr,
+                            void*,
+                            _Tp>::_Ret _Type;
+#endif
+};
+
+template <class _Tp, class _Compare>
+struct _AssocStorageTypes {
+  typedef _StorageType<_Tp> _StorageTypeInfo;
+  typedef typename _StorageTypeInfo::_Type _SType;
+
+  //We need to also check that the comparison functor used to instanciate the assoc container
+  //is the default Standard less implementation:
+  typedef typename _IsSTLportClass<_Compare>::_Ret _STLportLess;
+  enum { is_default_less = __type2bool<_STLportLess>::_Ret };
+
+  typedef typename __select<is_default_less, _SType, _Tp>::_Ret _KeyStorageType;
+  enum { ptr_type = _StorageTypeInfo::use_const_volatile_void_ptr };
+  typedef typename __select<is_default_less && ptr_type,
+                            _BinaryPredWrapper<_KeyStorageType, _Tp, _Compare>,
+                            _Compare>::_Ret _CompareStorageType;
+};
+
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/*
+ * Base struct to deal with qualifiers
+ */
+template <class _StorageT, class _QualifiedStorageT>
+struct _VoidCastTraitsAux {
+  typedef _QualifiedStorageT void_cv_type;
+  typedef _StorageT void_type;
+
+  static void_type * uncv_ptr(void_cv_type *__ptr)
+  { return __ptr; }
+  static void_type const* uncv_cptr(void_cv_type const*__ptr)
+  { return __ptr; }
+  static void_type ** uncv_pptr(void_cv_type **__ptr)
+  { return __ptr; }
+  static void_type & uncv_ref(void_cv_type & __ref)
+  { return __ref; }
+  static void_type const& uncv_cref(void_cv_type const& __ref)
+  { return __ref; }
+  static void_cv_type* cv_ptr(void_type *__ptr)
+  { return __ptr; }
+  static void_cv_type const* cv_cptr(void_type const*__ptr)
+  { return __ptr; }
+  static void_cv_type ** cv_pptr(void_type **__ptr)
+  { return __ptr; }
+  static void_cv_type & cv_ref(void_type & __ref)
+  { return __ref; }
+  static void_cv_type const& cv_cref(void_type const& __ref)
+  { return __ref; }
+};
+
+template <class _VoidCVType>
+struct _VoidCastTraitsAuxBase {
+  typedef _VoidCVType* void_cv_type;
+  typedef void* void_type;
+
+  static void_type* uncv_ptr(void_cv_type *__ptr)
+  { return __CONST_CAST(void_type*, __ptr); }
+  static void_type const* uncv_cptr(void_cv_type const*__ptr)
+  { return __CONST_CAST(void_type const*, __ptr); }
+  static void_type** uncv_pptr(void_cv_type **__ptr)
+  { return __CONST_CAST(void_type**, __ptr); }
+  static void_type& uncv_ref(void_cv_type &__ref)
+  { return __CONST_CAST(void_type&, __ref); }
+  static void_type const& uncv_cref(void_cv_type const& __ptr)
+  { return __CONST_CAST(void_type const&, __ptr); }
+  // The reverse versions
+  static void_cv_type * cv_ptr(void_type *__ptr)
+  { return __CONST_CAST(void_cv_type *, __ptr); }
+  static void_cv_type const* cv_cptr(void_type const*__ptr)
+  { return __CONST_CAST(void_cv_type const*, __ptr); }
+  static void_cv_type ** cv_pptr(void_type **__ptr)
+  { return __CONST_CAST(void_cv_type**, __ptr); }
+  static void_cv_type & cv_ref(void_type &__ref)
+  { return __CONST_CAST(void_cv_type &, __ref); }
+  static void_cv_type const& cv_cref(void_type const& __ref)
+  { return __CONST_CAST(void_cv_type const&, __ref); }
+};
+
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, const void*> : _VoidCastTraitsAuxBase<void const>
+{};
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, volatile void*> : _VoidCastTraitsAuxBase<void volatile>
+{};
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, const volatile void*> : _VoidCastTraitsAuxBase<void const volatile>
+{};
+
+template <class _StorageT, class _ValueT>
+struct _CastTraits {
+  typedef _ValueT value_type;
+  typedef typename _StorageType<_ValueT>::_QualifiedType _QualifiedStorageT;
+  typedef _VoidCastTraitsAux<_StorageT, _QualifiedStorageT> cv_traits;
+  typedef typename cv_traits::void_type void_type;
+  typedef typename cv_traits::void_cv_type void_cv_type;
+
+  static value_type * to_value_type_ptr(void_type *__ptr)
+  { return __REINTERPRET_CAST(value_type *, cv_traits::cv_ptr(__ptr)); }
+  static value_type const* to_value_type_cptr(void_type const*__ptr)
+  { return __REINTERPRET_CAST(value_type const*, cv_traits::cv_cptr(__ptr)); }
+  static value_type ** to_value_type_pptr(void_type **__ptr)
+  { return __REINTERPRET_CAST(value_type **, cv_traits::cv_pptr(__ptr)); }
+  static value_type & to_value_type_ref(void_type &__ref)
+  { return __REINTERPRET_CAST(value_type &, cv_traits::cv_ref(__ref)); }
+  static value_type const& to_value_type_cref(void_type const& __ptr)
+  { return __REINTERPRET_CAST(value_type const&, cv_traits::cv_cref(__ptr)); }
+  // Reverse versions
+  static void_type * to_storage_type_ptr(value_type *__ptr)
+  { return cv_traits::uncv_ptr(__REINTERPRET_CAST(void_cv_type *, __ptr)); }
+  static void_type const* to_storage_type_cptr(value_type const*__ptr)
+  { return cv_traits::uncv_cptr(__REINTERPRET_CAST(void_cv_type const*, __ptr)); }
+  static void_type ** to_storage_type_pptr(value_type **__ptr)
+  { return cv_traits::uncv_pptr(__REINTERPRET_CAST(void_cv_type **, __ptr)); }
+  static void_type const& to_storage_type_cref(value_type const& __ref)
+  { return cv_traits::uncv_cref(__REINTERPRET_CAST(void_cv_type const&, __ref)); }
+
+  //Method used to treat set container template method extension
+  static void_type const& to_storage_type_crefT(value_type const& __ref)
+  { return to_storage_type_cref(__ref); }
+};
+
+template <class _Tp>
+struct _CastTraits<_Tp, _Tp> {
+  typedef _Tp storage_type;
+  typedef _Tp value_type;
+
+  static value_type * to_value_type_ptr(storage_type *__ptr)
+  { return __ptr; }
+  static value_type const* to_value_type_cptr(storage_type const*__ptr)
+  { return __ptr; }
+  static value_type ** to_value_type_pptr(storage_type **__ptr)
+  { return __ptr; }
+  static value_type & to_value_type_ref(storage_type &__ref)
+  { return __ref; }
+  static value_type const& to_value_type_cref(storage_type const&__ref)
+  { return __ref; }
+  // Reverse versions
+  static storage_type * to_storage_type_ptr(value_type *__ptr)
+  { return __ptr; }
+  static storage_type const* to_storage_type_cptr(value_type const*__ptr)
+  { return __ptr; }
+  static storage_type ** to_storage_type_pptr(value_type **__ptr)
+  { return __ptr; }
+  static storage_type const& to_storage_type_cref(value_type const& __ref)
+  { return __ref; }
+
+  //Method used to treat set container template method extension
+  template <class _Tp1>
+  static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref)
+  { return __ref; }
+};
+
+#define _STLP_USE_ITERATOR_WRAPPER
+
+template <class _StorageT, class _ValueT, class _Iterator>
+struct _IteWrapper {
+  typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+  typedef iterator_traits<_Iterator> _IteTraits;
+
+  typedef typename _IteTraits::iterator_category iterator_category;
+  typedef _StorageT value_type;
+  typedef typename _IteTraits::difference_type difference_type;
+  typedef value_type* pointer;
+  typedef value_type const& const_reference;
+  //This wrapper won't be used for input so to avoid surprise
+  //the reference type will be a const reference:
+  typedef const_reference reference;
+
+  typedef _IteWrapper<_StorageT, _ValueT, _Iterator> _Self;
+  typedef _Self _Ite;
+
+  _IteWrapper(_Iterator &__ite) : _M_ite(__ite) {}
+
+  const_reference operator*() const { return cast_traits::to_storage_type_cref(*_M_ite); }
+
+  _Self& operator= (_Self const& __rhs) {
+    _M_ite = __rhs._M_ite;
+    return *this;
+  }
+
+  _Self& operator++() {
+    ++_M_ite;
+    return *this;
+  }
+
+  _Self& operator--() {
+    --_M_ite;
+    return *this;
+  }
+
+  _Self& operator += (difference_type __offset) {
+    _M_ite += __offset;
+    return *this;
+  }
+  difference_type operator -(_Self const& __other) const
+  { return _M_ite - __other._M_ite; }
+
+  bool operator == (_Self const& __other) const
+  { return _M_ite == __other._M_ite; }
+
+  bool operator != (_Self const& __other) const
+  { return _M_ite != __other._M_ite; }
+
+  bool operator < (_Self const& __rhs) const
+  { return _M_ite < __rhs._M_ite; }
+
+private:
+  _Iterator _M_ite;
+};
+
+template <class _Tp, class _Iterator>
+struct _IteWrapper<_Tp, _Tp, _Iterator>
+{ typedef _Iterator _Ite; };
+
+#else
+
+/*
+ * In this config the storage type is qualified in respect of the
+ * value_type qualification. Simple reinterpret_cast is enough.
+ */
+template <class _StorageT, class _ValueT>
+struct _CastTraits {
+  typedef _StorageT storage_type;
+  typedef _ValueT value_type;
+
+  static value_type * to_value_type_ptr(storage_type *__ptr)
+  { return __REINTERPRET_CAST(value_type*, __ptr); }
+  static value_type const* to_value_type_cptr(storage_type const*__ptr)
+  { return __REINTERPRET_CAST(value_type const*, __ptr); }
+  static value_type ** to_value_type_pptr(storage_type **__ptr)
+  { return __REINTERPRET_CAST(value_type **, __ptr); }
+  static value_type & to_value_type_ref(storage_type &__ref)
+  { return __REINTERPRET_CAST(value_type&, __ref); }
+  static value_type const& to_value_type_cref(storage_type const&__ref)
+  { return __REINTERPRET_CAST(value_type const&, __ref); }
+  // Reverse versions
+  static storage_type * to_storage_type_ptr(value_type *__ptr)
+  { return __REINTERPRET_CAST(storage_type*, __ptr); }
+  static storage_type const* to_storage_type_cptr(value_type const*__ptr)
+  { return __REINTERPRET_CAST(storage_type const*, __ptr); }
+  static storage_type ** to_storage_type_pptr(value_type **__ptr)
+  { return __REINTERPRET_CAST(storage_type **, __ptr); }
+  static storage_type const& to_storage_type_cref(value_type const&__ref)
+  { return __REINTERPRET_CAST(storage_type const&, __ref); }
+  template <class _Tp1>
+  static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref)
+  { return __ref; }
+};
+
+#endif
+
+//Wrapper functors:
+template <class _StorageT, class _ValueT, class _UnaryPredicate>
+struct _UnaryPredWrapper {
+  typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+  _UnaryPredWrapper (_UnaryPredicate const& __pred) : _M_pred(__pred) {}
+
+  bool operator () (_StorageT const& __ref) const
+  { return _M_pred(cast_traits::to_value_type_cref(__ref)); }
+
+private:
+  _UnaryPredicate _M_pred;
+};
+
+template <class _StorageT, class _ValueT, class _BinaryPredicate>
+struct _BinaryPredWrapper {
+  typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+  _BinaryPredWrapper () {}
+  _BinaryPredWrapper (_BinaryPredicate const& __pred) : _M_pred(__pred) {}
+
+  _BinaryPredicate get_pred() const { return _M_pred; }
+
+  bool operator () (_StorageT const& __fst, _StorageT const& __snd) const
+  { return _M_pred(cast_traits::to_value_type_cref(__fst), cast_traits::to_value_type_cref(__snd)); }
+
+  //Cast operator used to transparently access underlying predicate
+  //in set::key_comp() method
+  operator _BinaryPredicate() const
+  { return _M_pred; }
+
+private:
+  _BinaryPredicate _M_pred;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_POINTERS_SPEC_TOOLS_H */
diff --git a/WebKit/android/stlport/stl/pointers/_vector.h b/WebKit/android/stlport/stl/pointers/_vector.h
new file mode 100644
index 0000000..8de4c00
--- /dev/null
+++ b/WebKit/android/stlport/stl/pointers/_vector.h
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_VECTOR_H
+#define _STLP_SPECIALIZED_VECTOR_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#  include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define VECTOR_IMPL _STLP_PTR_IMPL_NAME(vector)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV _Vector_base<void*,allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV VECTOR_IMPL<void*, allocator<void*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+#  define vector _STLP_NON_DBG_NAME(vector)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
+class vector
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (vector)
+             : public __stlport_class<vector<_Tp, _Alloc> >
+#endif
+{
+  /* In the vector implementation iterators are pointer which give a number
+   * of opportunities for optimization. To not break those optimizations
+   * iterators passed to template should not be wrapped for casting purpose.
+   * So vector implementation will always use a qualified void pointer type and
+   * won't use iterator wrapping.
+   */
+  typedef typename _STLP_PRIV _StorageType<_Tp>::_QualifiedType _StorageType;
+  typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+  typedef _STLP_PRIV VECTOR_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+  typedef vector<_Tp, _Alloc> _Self;
+
+  typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+
+public:
+  typedef _Tp value_type;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type* iterator;
+  typedef const value_type* const_iterator;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef random_access_iterator_tag _Iterator_category;
+
+  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+  _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+  typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+  iterator begin()             { return cast_traits::to_value_type_ptr(_M_impl.begin()); }
+  const_iterator begin() const { return cast_traits::to_value_type_cptr(_M_impl.begin()); }
+  iterator end()               { return cast_traits::to_value_type_ptr(_M_impl.end()); }
+  const_iterator end() const   { return cast_traits::to_value_type_cptr(_M_impl.end()); }
+
+  reverse_iterator rbegin()              { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const  { return const_reverse_iterator(end()); }
+  reverse_iterator rend()                { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const    { return const_reverse_iterator(begin()); }
+
+  size_type size() const        { return _M_impl.size(); }
+  size_type max_size() const    { return _M_impl.max_size(); }
+
+  size_type capacity() const    { return _M_impl.capacity(); }
+  bool empty() const            { return _M_impl.empty(); }
+
+  reference operator[](size_type __n) { return cast_traits::to_value_type_ref(_M_impl[__n]); }
+  const_reference operator[](size_type __n) const { return cast_traits::to_value_type_cref(_M_impl[__n]); }
+
+  reference front()             { return cast_traits::to_value_type_ref(_M_impl.front()); }
+  const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); }
+  reference back()              { return cast_traits::to_value_type_ref(_M_impl.back()); }
+  const_reference back() const  { return cast_traits::to_value_type_cref(_M_impl.back()); }
+
+  reference at(size_type __n) { return cast_traits::to_value_type_ref(_M_impl.at(__n)); }
+  const_reference at(size_type __n) const { return cast_traits::to_value_type_cref(_M_impl.at(__n)); }
+
+  explicit vector(const allocator_type& __a = allocator_type())
+    : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit vector(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+  vector(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+         const allocator_type& __a = allocator_type())
+    : _M_impl(__n, cast_traits::to_storage_type_cref(__val),
+      _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  explicit vector(size_type __n)
+    : _M_impl(__n, allocator_type() ) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  vector(const _Self& __x)
+    : _M_impl(__x._M_impl) {}
+
+  explicit vector(__move_source<_Self> src)
+    : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  vector(_InputIterator __first, _InputIterator __last,
+         const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL )
+  : _M_impl(__first, __last,
+            _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  vector(_InputIterator __first, _InputIterator __last)
+    : _M_impl(__first, __last) {}
+#  endif
+
+#else
+  vector(const_iterator __first, const_iterator __last,
+         const allocator_type& __a = allocator_type())
+    : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
+              _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+  _Self& operator=(const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+  void reserve(size_type __n) {_M_impl.reserve(__n);}
+  void assign(size_type __n, const value_type& __val)
+  { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void assign(_InputIterator __first, _InputIterator __last)
+  { _M_impl.assign(__first, __last); }
+#else
+  void assign(const_iterator __first, const_iterator __last) {
+    _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+                   cast_traits::to_storage_type_cptr(__last));
+  }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  void push_back(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void push_back(const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  iterator insert(iterator __pos, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+  { return cast_traits::to_value_type_ptr(_M_impl.insert(cast_traits::to_storage_type_ptr(__pos),
+                                                         cast_traits::to_storage_type_cref(__x))); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+  void push_back() { _M_impl.push_back(); }
+  iterator insert(iterator __pos)
+  { return _M_impl.insert(cast_traits::to_storage_type_ptr(__pos)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+  void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+  template <class _InputIterator>
+  void insert(iterator __pos, _InputIterator __first, _InputIterator __last)
+  { _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __first, __last); }
+#else
+  void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+    _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), cast_traits::to_storage_type_cptr(__first),
+                                                            cast_traits::to_storage_type_cptr(__last));
+  }
+#endif
+
+  void insert (iterator __pos, size_type __n, const value_type& __x) {
+    _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __n, cast_traits::to_storage_type_cref(__x));
+  }
+
+  void pop_back() {_M_impl.pop_back();}
+  iterator erase(iterator __pos)
+  {return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__pos)));}
+  iterator erase(iterator __first, iterator __last) {
+    return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__first),
+                                                        cast_traits::to_storage_type_ptr(__last)));
+  }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+  void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+  { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+  void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+  void clear() { _M_impl.clear(); }
+
+private:
+  _Base _M_impl;
+};
+
+#if defined (vector)
+#  undef vector
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef VECTOR_IMPL
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_VECTOR_H */