Code drop from //branches/cupcake/...@124589

12 files changed, 2596 insertions, 0 deletions

diff --git a/WebKit/android/stl/algorithm b/WebKit/android/stl/algorithm
new file mode 100644
index 0000000..8255def
--- /dev/null
+++ b/WebKit/android/stl/algorithm
@@ -0,0 +1,274 @@
+#ifdef __cplusplus
+
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+ 
+ // extracted from stl_algobase.h 
+ // full STL is not compatible with the ARM build
+ // a limited number of STL functions is used by webkit: swap, max, and min are 
+ // included below for webkit compatibility
+ 
+#ifdef __GLIBCPP_INTERNAL_ALGOBASE_H
+#error "real STL defined"
+#endif
+
+#ifndef __ANDROID_ALGORITHM
+#define __ANDROID_ALGORITHM
+
+#ifndef __ANDROID_LIMITS
+#include <limits>
+#endif
+
+#ifndef _CPP_UTILITY
+#include <utility>
+#endif
+
+#include <SkScalar.h> // for SK_ScalarNaN
+#ifdef PREFIX_FOR_WEBCORE
+#include <SkTSearch.h>
+namespace WebCore {
+    class InlineTextBox;
+    class RenderLayer;
+}
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+
+#ifndef WCHAR_MAX
+	#define WCHAR_MAX	0xFFFF
+#endif
+
+namespace JSC {
+    class ProfileNode;
+}
+
+namespace WTF {
+    template <typename T> class RefPtr;
+}
+
+namespace std
+{
+  template<typename _Tp>
+    inline void
+    swap(_Tp& __a, _Tp& __b)
+    {
+      _Tp __tmp = __a;
+      __a = __b;
+      __b = __tmp;
+    }
+
+  #undef min
+  #undef max
+
+  template<typename _Tp>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+      return __b < __a ? __b : __a;
+    }
+
+  template<typename _Tp>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+      return  __a < __b ? __b : __a;
+    }
+    
+template <class _InputIter, class _OutputIter>
+inline _OutputIter copy(_InputIter __first, _InputIter __last,
+                        _OutputIter __result)
+{
+  for (size_t __n = __last - __first; __n > 0; --__n) {
+    *__result = *__first;
+    ++__first;
+    ++__result;
+  }
+  return __result;
+}
+
+template <class _ForwardIter, class _Tp>
+void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) {
+  for ( ; __first != __last; ++__first)
+    *__first = __value;
+}
+
+#ifndef UINTPTR_MAX
+#define UINTPTR_MAX	UINT32_MAX
+#endif
+
+#ifndef UINT32_MAX
+#define UINT32_MAX    (0xffffffff)
+#endif
+
+template <typename T> 
+struct numeric_limits {
+    /// Returns the minimum value for type T.
+    static inline T min (void)		{ return (T(0)); }
+    /// Returns the minimum value for type T.
+    static inline T max (void)		{ return (T(0)); }
+    static const bool is_signed = false;	///< True if the type is signed.
+    static const bool is_integer = false;	///< True if stores an exact value.
+    static const bool is_integral = false;	///< True if fixed size and cast-copyable.
+};
+
+template <typename T>
+struct numeric_limits<T*> {
+    static inline T* min (void)	{ return (NULL); }
+    static inline T* max (void)	{ return (UINTPTR_MAX); }
+    static const bool is_signed = false;
+    static const bool is_integer = true;
+    static const bool is_integral = true;
+};
+
+#define _NUMERIC_LIMITS(type, minVal, maxVal, quietNaN, bSigned, bInteger, bIntegral)	\
+template <>							\
+struct numeric_limits<type> {					\
+    static inline type infinity (void)	{ return (maxVal); }	\
+    static inline type min (void)	{ return (minVal); }	\
+    static inline type max (void)	{ return (maxVal); }	\
+    static inline type quiet_NaN() { return (quietNaN); } \
+    static const bool is_signed = bSigned;			\
+    static const bool is_integer = bInteger;			\
+    static const bool is_integral = bIntegral;			\
+}
+
+//--------------------------------------------------------------------------------------
+//		         type		    min		    max		    NaN     signed	integer	integral
+//--------------------------------------------------------------------------------------
+_NUMERIC_LIMITS (bool,		    false,		true,		0,      false,	true,	true);
+_NUMERIC_LIMITS (char,		    SCHAR_MIN,	SCHAR_MAX,	0,      true,	true,	true);
+_NUMERIC_LIMITS (int,		    INT_MIN,	INT_MAX,	0,      true,	true,	true);
+_NUMERIC_LIMITS (short,		    SHRT_MIN,	SHRT_MAX,	0,      true,	true,	true);
+_NUMERIC_LIMITS (long,		    LONG_MIN,	LONG_MAX,	0,      true,	true,	true);
+#if HAVE_THREE_CHAR_TYPES
+_NUMERIC_LIMITS (signed char,	SCHAR_MIN,	SCHAR_MAX,	0,      true,	true,	true);
+#endif
+_NUMERIC_LIMITS (unsigned char,	0,		    UCHAR_MAX,	0,      false,	true,	true);
+_NUMERIC_LIMITS (unsigned int,	0,		    UINT_MAX,	0,      false,	true,	true);
+_NUMERIC_LIMITS (unsigned short,0,		    USHRT_MAX,	0,      false,	true,	true);
+_NUMERIC_LIMITS (unsigned long,	0,		    ULONG_MAX,	0,      false,	true,	true);
+_NUMERIC_LIMITS (wchar_t,	    0,		    WCHAR_MAX,	0,      false,	true,	true);
+_NUMERIC_LIMITS (float,		    FLT_MIN,	FLT_MAX,  SK_ScalarNaN, true,	false,	true);
+_NUMERIC_LIMITS (double,	    DBL_MIN,	DBL_MAX,  SK_ScalarNaN, true,	false,	true);
+_NUMERIC_LIMITS (long double,	LDBL_MIN,	LDBL_MAX, SK_ScalarNaN, true,	false,	true);
+#ifdef HAVE_LONG_LONG
+_NUMERIC_LIMITS (long long,	    LLONG_MIN,	LLONG_MAX,	0,      true,	true,	true);
+_NUMERIC_LIMITS (unsigned long long,	0,	ULLONG_MAX,	0,      false,	true,	true);
+#endif
+//--------------------------------------------------------------------------------------
+
+typedef int ptrdiff_t;
+
+typedef bool (* Comparator)(const void*, const void*);
+extern void sort(const void** start, const void** end, Comparator comp);
+
+#ifdef PREFIX_FOR_WEBCORE
+    typedef const void* sortType;
+
+    inline bool binary_search(const unsigned short* const base,
+                              const unsigned short* const end,
+                              short target)
+    {
+        return SkTSearch<unsigned short>(base, end - base, target, sizeof(unsigned short)) >= 0;
+    }
+
+    
+    inline void sort (WebCore::InlineTextBox** start, WebCore::InlineTextBox**end, 
+        bool (* comp)(const WebCore::InlineTextBox*, const WebCore::InlineTextBox*)) 
+    {
+        sort((const void**) start, (const void**) end, (Comparator) comp);
+    }
+    
+    template<typename P> inline void stable_sort(P** start, P** end,
+       bool (* comp)(P*, P*))
+    {
+        sort((const void**) start, (const void**) end, (Comparator) comp);
+    }
+    
+    template<typename P> inline void stable_sort(P** start, P** end,
+       bool (& comp)(const P*, const P*))
+    {
+        sort((const void**) start, (const void**) end, (Comparator) &comp);
+    }
+    
+    template<typename P> void stable_sort(P* start, P* end, P* temp,
+            bool (& comp)(const P&, const P&)) {
+        size_t endlen = end - start;
+        size_t midlen = endlen / 2;
+        P* mid = start + midlen;
+        if (midlen > 1)
+            stable_sort(start, mid, temp, comp);
+        if (end - mid > 1)
+            stable_sort(mid, end, temp, comp);
+        memcpy(temp, start, midlen * sizeof(*start));
+        size_t i = 0;
+        size_t j = midlen;
+        size_t off = 0;
+        while (i < midlen && j < endlen) {
+            P* dst = (comp)(start[j], temp[i]) ? &start[j++] : &temp[i++];
+            memcpy(&start[off++], dst, sizeof(*start));
+        }
+        if (i < midlen)
+            memcpy(&start[off], &temp[i], (midlen - i) * sizeof(*start));
+    }
+
+    template<typename P> void stable_sort(P* start, P* end,
+            bool (& comp)(const P&, const P&)) {
+        if (end - start > 1) {
+            size_t count = (end - start) / 2;
+            P* temp = static_cast<P*>(malloc(count * sizeof(P)));
+            stable_sort(start, end, temp, comp);
+            free(temp);
+        }
+    }
+
+    template<typename P> void stable_sort(P* start, P* end,
+            bool (& comp)(P, P)) {
+	stable_sort(start, end, (bool (&)(const P&, const P&))(comp));
+    }
+   
+    class ostream {
+        int this_class_intentionally_left_empty;
+    };
+#endif
+
+typedef bool (* ProfileComparator)(const WTF::RefPtr<JSC::ProfileNode>&, 
+    const WTF::RefPtr<JSC::ProfileNode>&);
+
+inline void sort(WTF::RefPtr<JSC::ProfileNode>* start, 
+        WTF::RefPtr<JSC::ProfileNode>* end, ProfileComparator comp) 
+{
+    sort((const void**) start, (const void**) end, (Comparator) comp);
+}
+
+}
+
+#endif
+
+#endif // __cplusplus
+
diff --git a/WebKit/android/stl/concept_checks.h b/WebKit/android/stl/concept_checks.h
new file mode 100644
index 0000000..36df283
--- /dev/null
+++ b/WebKit/android/stl/concept_checks.h
@@ -0,0 +1,811 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __CONCEPT_CHECKS_H
+#define __CONCEPT_CHECKS_H
+
+/*
+  Use these macro like assertions, but they assert properties
+  on types (usually template arguments). In technical terms they
+  verify whether a type "models" a "concept".
+
+  This set of requirements and the terminology used here is derived
+  from the book "Generic Programming and the STL" by Matt Austern
+  (Addison Wesley). For further information please consult that
+  book. The requirements also are intended to match the ANSI/ISO C++
+  standard.
+
+  This file covers the basic concepts and the iterator concepts.
+  There are several other files that provide the requirements
+  for the STL containers:
+    container_concepts.h
+    sequence_concepts.h
+    assoc_container_concepts.h
+
+  Jeremy Siek, 1999
+
+  TO DO:
+    - some issues with regards to concept classification and mutability
+      including AssociativeContianer -> ForwardContainer
+      and SortedAssociativeContainer -> ReversibleContainer
+    - HashedAssociativeContainer
+    - Allocator
+    - Function Object Concepts
+
+  */
+
+#ifndef __STL_USE_CONCEPT_CHECKS
+
+// Some compilers lack the features that are necessary for concept checks.
+// On those compilers we define the concept check macros to do nothing.
+#define __STL_REQUIRES(__type_var, __concept) do {} while(0)
+#define __STL_CLASS_REQUIRES(__type_var, __concept) \
+  static int  __##__type_var##_##__concept
+#define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0)
+#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
+#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+  static int  __##__type_x##__type_y##_require_same_type
+#define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0)
+#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
+  static int  __##__func##__ret##_generator_check
+#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
+#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+  static int  __##__func##__ret##__arg##_unary_function_check
+#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+  do {} while(0)
+#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+  static int  __##__func##__ret##__first##__second##_binary_function_check
+#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+  do {} while(0)
+#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+  static int __##__opname##__ret##__first##__second##_require_binary_op
+
+#else /* __STL_USE_CONCEPT_CHECKS */
+
+// This macro tests whether the template argument "__type_var"
+// satisfies the requirements of "__concept".  Here is a list of concepts
+// that we know how to check:
+//       _Allocator
+//       _Assignable
+//       _DefaultConstructible
+//       _EqualityComparable
+//       _LessThanComparable
+//       _TrivialIterator
+//       _InputIterator
+//       _OutputIterator
+//       _ForwardIterator
+//       _BidirectionalIterator
+//       _RandomAccessIterator
+//       _Mutable_TrivialIterator
+//       _Mutable_ForwardIterator
+//       _Mutable_BidirectionalIterator
+//       _Mutable_RandomAccessIterator
+
+#define __STL_REQUIRES(__type_var, __concept) \
+do { \
+  void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
+    ::__concept##_requirement_violation; __x = __x; } while (0)
+
+// Use this to check whether type X is convertible to type Y
+#define __STL_CONVERTIBLE(__type_x, __type_y) \
+do { \
+  void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
+  __type_y >::__type_X_is_not_convertible_to_type_Y; \
+  __x = __x; } while (0)
+
+// Use this to test whether two template arguments are the same type
+#define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+do { \
+  void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
+    __type_y  >::__type_X_not_same_as_type_Y; \
+  __x = __x; } while (0)
+
+
+// function object checks
+#define __STL_GENERATOR_CHECK(__func, __ret) \
+do { \
+  __ret (*__x)( __func&) = \
+     _STL_GENERATOR_ERROR< \
+  __func, __ret>::__generator_requirement_violation; \
+  __x = __x; } while (0)
+
+
+#define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+do { \
+  __ret (*__x)( __func&, const __arg& ) = \
+     _STL_UNARY_FUNCTION_ERROR< \
+  __func, __ret, __arg>::__unary_function_requirement_violation; \
+  __x = __x; } while (0)
+
+
+#define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+do { \
+  __ret (*__x)( __func&, const __first&, const __second& ) = \
+     _STL_BINARY_FUNCTION_ERROR< \
+  __func, __ret, __first, __second>::__binary_function_requirement_violation; \
+  __x = __x; } while (0)
+
+
+#define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+    do { \
+  __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
+    __ret, __first, __second>::__binary_operator_requirement_violation; \
+  __ret (*__y)( const __first&, const __second& ) = \
+    _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
+      __const_binary_operator_requirement_violation; \
+  __y = __y; __x = __x; } while (0)
+
+
+#ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
+
+#define __STL_CLASS_REQUIRES(__type_var, __concept)
+#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
+#define __STL_CLASS_GENERATOR_CHECK(__func, __ret)
+#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
+#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
+#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)
+
+#else
+
+// Use this macro inside of template classes, where you would
+// like to place requirements on the template arguments to the class
+// Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
+// since the type_var is used to construct identifiers. Instead typedef
+// the pointer type, then use the typedef name for the __type_var.
+#define __STL_CLASS_REQUIRES(__type_var, __concept) \
+  typedef void (* __func##__type_var##__concept)( __type_var ); \
+  template <__func##__type_var##__concept _Tp1> \
+  struct __dummy_struct_##__type_var##__concept { }; \
+  static __dummy_struct_##__type_var##__concept< \
+    __concept##_concept_specification< \
+      __type_var>::__concept##_requirement_violation>  \
+  __dummy_ptr_##__type_var##__concept
+
+
+#define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+  typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
+                                                            __type_y ); \
+  template < __func_##__type_x##__type_y##same_type _Tp1> \
+  struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
+  static __dummy_struct_##__type_x##__type_y##_same_type< \
+    _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y>  \
+  __dummy_ptr_##__type_x##__type_y##_same_type
+
+
+#define __STL_CLASS_GENERATOR_CHECK(__func, __ret) \
+  typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
+  template <__f_##__func##__ret##_generator _Tp1> \
+  struct __dummy_struct_##__func##__ret##_generator { }; \
+  static __dummy_struct_##__func##__ret##_generator< \
+    _STL_GENERATOR_ERROR< \
+      __func, __ret>::__generator_requirement_violation>  \
+  __dummy_ptr_##__func##__ret##_generator
+
+
+#define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+  typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
+                                                         const __arg& ); \
+  template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
+  struct __dummy_struct_##__func##__ret##__arg##_unary_check { }; \
+  static __dummy_struct_##__func##__ret##__arg##_unary_check< \
+    _STL_UNARY_FUNCTION_ERROR< \
+      __func, __ret, __arg>::__unary_function_requirement_violation>  \
+  __dummy_ptr_##__func##__ret##__arg##_unary_check
+
+
+#define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+  typedef __ret (* __f_##__func##__ret##__first##__second##_binary_check)( __func&, const __first&,\
+                                                    const __second& ); \
+  template <__f_##__func##__ret##__first##__second##_binary_check _Tp1> \
+  struct __dummy_struct_##__func##__ret##__first##__second##_binary_check { }; \
+  static __dummy_struct_##__func##__ret##__first##__second##_binary_check< \
+    _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
+  __binary_function_requirement_violation>  \
+  __dummy_ptr_##__func##__ret##__first##__second##_binary_check
+
+
+#define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+  typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op)(const __first&, \
+                                                    const __second& ); \
+  template <__f_##__func##__ret##__first##__second##_binary_op _Tp1> \
+  struct __dummy_struct_##__func##__ret##__first##__second##_binary_op { }; \
+  static __dummy_struct_##__func##__ret##__first##__second##_binary_op< \
+    _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
+  __binary_operator_requirement_violation>  \
+  __dummy_ptr_##__func##__ret##__first##__second##_binary_op
+
+#endif
+
+/* helper class for finding non-const version of a type. Need to have
+   something to assign to etc. when testing constant iterators. */
+
+template <class _Tp>
+struct _Mutable_trait {
+  typedef _Tp _Type;
+};
+template <class _Tp>
+struct _Mutable_trait<const _Tp> {
+  typedef _Tp _Type;
+};
+
+
+/* helper function for avoiding compiler warnings about unused variables */
+template <class _Type>
+void __sink_unused_warning(_Type) { }
+
+template <class _TypeX, class _TypeY>
+struct _STL_CONVERT_ERROR {
+  static void
+  __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
+    _TypeY __y = __x;
+    __sink_unused_warning(__y);
+  }
+};
+
+
+template <class _Type> struct __check_equal { };
+
+template <class _TypeX, class _TypeY>
+struct _STL_SAME_TYPE_ERROR {
+  static void
+  __type_X_not_same_as_type_Y(_TypeX , _TypeY ) { 
+    __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
+  }
+};
+
+
+// Some Functon Object Checks
+
+template <class _Func, class _Ret>
+struct _STL_GENERATOR_ERROR {
+  static _Ret __generator_requirement_violation(_Func& __f) {
+    return __f();
+  }
+};
+
+template <class _Func>
+struct _STL_GENERATOR_ERROR<_Func, void> {
+  static void __generator_requirement_violation(_Func& __f) {
+    __f();
+  }
+};
+
+
+template <class _Func, class _Ret, class _Arg>
+struct _STL_UNARY_FUNCTION_ERROR {
+  static _Ret
+  __unary_function_requirement_violation(_Func& __f,
+                                          const _Arg& __arg) {
+    return __f(__arg);
+  }
+};
+
+template <class _Func, class _Arg>
+struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
+  static void
+  __unary_function_requirement_violation(_Func& __f,
+                                          const _Arg& __arg) {
+    __f(__arg);
+  }
+};
+
+template <class _Func, class _Ret, class _First, class _Second>
+struct _STL_BINARY_FUNCTION_ERROR {
+  static _Ret
+  __binary_function_requirement_violation(_Func& __f,
+                                          const _First& __first, 
+                                          const _Second& __second) {
+    return __f(__first, __second);
+  }
+};
+
+template <class _Func, class _First, class _Second>
+struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
+  static void
+  __binary_function_requirement_violation(_Func& __f,
+                                          const _First& __first, 
+                                          const _Second& __second) {
+    __f(__first, __second);
+  }
+};
+
+
+#define __STL_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
+template <class _Ret, class _First, class _Second> \
+struct _STL_BINARY##_NAME##_ERROR { \
+  static _Ret \
+  __const_binary_operator_requirement_violation(const _First& __first,  \
+                                                const _Second& __second) { \
+    return __first _OP __second; \
+  } \
+  static _Ret \
+  __binary_operator_requirement_violation(_First& __first,  \
+                                          _Second& __second) { \
+    return __first _OP __second; \
+  } \
+}
+
+__STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
+__STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
+__STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
+__STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
+__STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
+__STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
+__STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
+__STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
+__STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
+__STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
+__STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
+// ...
+
+// TODO, add unary operators (prefix and postfix)
+
+/*
+  The presence of this class is just to trick EDG into displaying
+  these error messages before any other errors. Without the
+  classes, the errors in the functions get reported after
+  other class errors deep inside the library. The name
+  choice just makes for an eye catching error message :)
+ */
+struct _STL_ERROR {
+
+  template <class _Type>
+  static _Type
+  __default_constructor_requirement_violation(_Type) {
+    return _Type();
+  }
+  template <class _Type>
+  static _Type
+  __assignment_operator_requirement_violation(_Type __a) {
+    __a = __a;
+    return __a;
+  }
+  template <class _Type>
+  static _Type
+  __copy_constructor_requirement_violation(_Type __a) {
+    _Type __c(__a);
+    return __c;
+  }
+  template <class _Type>
+  static _Type
+  __const_parameter_required_for_copy_constructor(_Type /* __a */, 
+                                                  const _Type& __b) {
+    _Type __c(__b);
+    return __c;
+  }
+  template <class _Type>
+  static _Type
+  __const_parameter_required_for_assignment_operator(_Type __a, 
+                                                     const _Type& __b) {
+    __a = __b;
+    return __a;
+  }
+  template <class _Type>
+  static _Type
+  __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
+    if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
+    return __b;
+  }
+  template <class _Type>
+  static _Type
+  __equality_comparable_requirement_violation(_Type __a, _Type __b) {
+    if (__a == __b || __a != __b) return __a;
+    return __b;
+  }
+  template <class _Iterator>
+  static void
+  __dereference_operator_requirement_violation(_Iterator __i) {
+    __sink_unused_warning(*__i);
+  }
+  template <class _Iterator>
+  static void
+  __dereference_operator_and_assignment_requirement_violation(_Iterator __i) {
+    *__i = *__i;
+  }
+  template <class _Iterator>
+  static void
+  __preincrement_operator_requirement_violation(_Iterator __i) {
+    ++__i;
+  }
+  template <class _Iterator>
+  static void
+  __postincrement_operator_requirement_violation(_Iterator __i) {
+    __i++;
+  }
+  template <class _Iterator>
+  static void
+  __predecrement_operator_requirement_violation(_Iterator __i) {
+    --__i;
+  }
+  template <class _Iterator>
+  static void
+  __postdecrement_operator_requirement_violation(_Iterator __i) {
+    __i--;
+  }
+  template <class _Iterator, class _Type>
+  static void
+  __postincrement_operator_and_assignment_requirement_violation(_Iterator __i,
+                                                                _Type __t) {
+    *__i++ = __t;
+  }
+  template <class _Iterator, class _Distance>
+  static _Iterator
+  __iterator_addition_assignment_requirement_violation(_Iterator __i, 
+                                                       _Distance __n) {
+    __i += __n;
+    return __i;
+  }
+  template <class _Iterator, class _Distance>
+  static _Iterator
+  __iterator_addition_requirement_violation(_Iterator __i, _Distance __n) {
+    __i = __i + __n;
+    __i = __n + __i;
+    return __i;
+  }
+  template <class _Iterator, class _Distance>
+  static _Iterator
+  __iterator_subtraction_assignment_requirement_violation(_Iterator __i,
+                                                          _Distance __n) {
+    __i -= __n;
+    return __i;
+  }
+  template <class _Iterator, class _Distance>
+  static _Iterator
+  __iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) {
+    __i = __i - __n;
+    return __i;
+  }
+  template <class _Iterator, class _Distance>
+  static _Distance
+  __difference_operator_requirement_violation(_Iterator __i, _Iterator __j,
+                                              _Distance __n) {
+    __n = __i - __j;
+    return __n;
+  }
+  template <class _Exp, class _Type, class _Distance>
+  static _Type
+  __element_access_operator_requirement_violation(_Exp __x, _Type*,
+                                                  _Distance __n) {
+    return __x[__n];
+  }
+  template <class _Exp, class _Type, class _Distance>
+  static void
+  __element_assignment_operator_requirement_violation(_Exp __x,
+                                                      _Type* __t,
+                                                      _Distance __n) {
+    __x[__n] = *__t;
+  }
+
+}; /* _STL_ERROR */
+
+/* Associated Type Requirements */
+
+__STL_BEGIN_NAMESPACE
+template <class _Iterator> struct iterator_traits;
+__STL_END_NAMESPACE
+
+template <class _Iter> 
+struct __value_type_type_definition_requirement_violation {
+  typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
+};
+
+template <class _Iter> 
+struct __difference_type_type_definition_requirement_violation {
+  typedef typename __STD::iterator_traits<_Iter>::difference_type
+          difference_type;
+};
+
+template <class _Iter> 
+struct __reference_type_definition_requirement_violation {
+  typedef typename __STD::iterator_traits<_Iter>::reference reference;
+};
+
+template <class _Iter> 
+struct __pointer_type_definition_requirement_violation {
+  typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
+};
+
+template <class _Iter> 
+struct __iterator_category_type_definition_requirement_violation {
+  typedef typename __STD::iterator_traits<_Iter>::iterator_category 
+          iterator_category;
+};
+
+/* Assignable Requirements */
+
+
+template <class _Type>
+struct _Assignable_concept_specification {
+  static void _Assignable_requirement_violation(_Type __a) {
+    _STL_ERROR::__assignment_operator_requirement_violation(__a);
+    _STL_ERROR::__copy_constructor_requirement_violation(__a);
+    _STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a);
+    _STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a);
+  }
+};
+
+/* DefaultConstructible Requirements */
+
+
+template <class _Type>
+struct _DefaultConstructible_concept_specification {
+  static void _DefaultConstructible_requirement_violation(_Type __a) {
+    _STL_ERROR::__default_constructor_requirement_violation(__a);
+  }
+};
+
+/* EqualityComparable Requirements */
+
+template <class _Type>
+struct _EqualityComparable_concept_specification {
+  static void _EqualityComparable_requirement_violation(_Type __a) {
+    _STL_ERROR::__equality_comparable_requirement_violation(__a, __a);
+  }
+};
+
+/* LessThanComparable Requirements */
+template <class _Type>
+struct _LessThanComparable_concept_specification {
+  static void _LessThanComparable_requirement_violation(_Type __a) {
+    _STL_ERROR::__less_than_comparable_requirement_violation(__a, __a);
+  }
+};
+
+/* TrivialIterator Requirements */
+
+template <class _TrivialIterator>
+struct _TrivialIterator_concept_specification {
+static void
+_TrivialIterator_requirement_violation(_TrivialIterator __i) {
+  typedef typename
+    __value_type_type_definition_requirement_violation<_TrivialIterator>::
+    value_type __T;
+  // Refinement of Assignable
+  _Assignable_concept_specification<_TrivialIterator>::
+    _Assignable_requirement_violation(__i);
+  // Refinement of DefaultConstructible
+  _DefaultConstructible_concept_specification<_TrivialIterator>::
+    _DefaultConstructible_requirement_violation(__i);
+  // Refinement of EqualityComparable
+  _EqualityComparable_concept_specification<_TrivialIterator>::
+    _EqualityComparable_requirement_violation(__i);
+  // Valid Expressions
+  _STL_ERROR::__dereference_operator_requirement_violation(__i);
+}
+};
+
+template <class _TrivialIterator>
+struct _Mutable_TrivialIterator_concept_specification {
+static void
+_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) {
+  _TrivialIterator_concept_specification<_TrivialIterator>::
+    _TrivialIterator_requirement_violation(__i);
+  // Valid Expressions
+  _STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i);
+}
+};
+
+/* InputIterator Requirements */
+
+template <class _InputIterator>
+struct _InputIterator_concept_specification {
+static void
+_InputIterator_requirement_violation(_InputIterator __i) {
+  // Refinement of TrivialIterator
+  _TrivialIterator_concept_specification<_InputIterator>::
+    _TrivialIterator_requirement_violation(__i);
+  // Associated Types
+  __difference_type_type_definition_requirement_violation<_InputIterator>();
+  __reference_type_definition_requirement_violation<_InputIterator>();
+  __pointer_type_definition_requirement_violation<_InputIterator>();
+  __iterator_category_type_definition_requirement_violation<_InputIterator>();
+  // Valid Expressions
+  _STL_ERROR::__preincrement_operator_requirement_violation(__i);
+  _STL_ERROR::__postincrement_operator_requirement_violation(__i);
+}
+};
+
+/* OutputIterator Requirements */
+
+template <class _OutputIterator>
+struct _OutputIterator_concept_specification {
+static void
+_OutputIterator_requirement_violation(_OutputIterator __i) {
+  // Refinement of Assignable
+  _Assignable_concept_specification<_OutputIterator>::
+    _Assignable_requirement_violation(__i);
+  // Associated Types
+  __iterator_category_type_definition_requirement_violation<_OutputIterator>();
+  // Valid Expressions
+  _STL_ERROR::__dereference_operator_requirement_violation(__i);
+  _STL_ERROR::__preincrement_operator_requirement_violation(__i);
+  _STL_ERROR::__postincrement_operator_requirement_violation(__i);
+  _STL_ERROR::
+    __postincrement_operator_and_assignment_requirement_violation(__i, *__i);
+}
+};
+
+/* ForwardIterator Requirements */
+
+template <class _ForwardIterator>
+struct _ForwardIterator_concept_specification {
+static void
+_ForwardIterator_requirement_violation(_ForwardIterator __i) {
+  // Refinement of InputIterator
+  _InputIterator_concept_specification<_ForwardIterator>::
+    _InputIterator_requirement_violation(__i);
+}
+};
+
+template <class _ForwardIterator>
+struct _Mutable_ForwardIterator_concept_specification {
+static void
+_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) {
+  _ForwardIterator_concept_specification<_ForwardIterator>::
+    _ForwardIterator_requirement_violation(__i);
+  // Refinement of OutputIterator
+  _OutputIterator_concept_specification<_ForwardIterator>::
+    _OutputIterator_requirement_violation(__i);
+}
+};
+
+/* BidirectionalIterator Requirements */
+
+template <class _BidirectionalIterator>
+struct _BidirectionalIterator_concept_specification {
+static void
+_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) {
+  // Refinement of ForwardIterator
+  _ForwardIterator_concept_specification<_BidirectionalIterator>::
+    _ForwardIterator_requirement_violation(__i);
+  // Valid Expressions
+  _STL_ERROR::__predecrement_operator_requirement_violation(__i);
+  _STL_ERROR::__postdecrement_operator_requirement_violation(__i);
+}
+};
+
+template <class _BidirectionalIterator>
+struct _Mutable_BidirectionalIterator_concept_specification {
+static void
+_Mutable_BidirectionalIterator_requirement_violation(
+       _BidirectionalIterator __i)
+{
+  _BidirectionalIterator_concept_specification<_BidirectionalIterator>::
+    _BidirectionalIterator_requirement_violation(__i);
+  // Refinement of mutable_ForwardIterator
+  _Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>::
+    _Mutable_ForwardIterator_requirement_violation(__i);
+  typedef typename
+    __value_type_type_definition_requirement_violation<
+    _BidirectionalIterator>::value_type __T;
+  typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0;
+  // Valid Expressions
+  _STL_ERROR::
+    __postincrement_operator_and_assignment_requirement_violation(__i,
+                                                                  *__tmp_ptr);
+}
+};
+
+/* RandomAccessIterator Requirements */
+
+template <class _RandAccIter>
+struct _RandomAccessIterator_concept_specification {
+static void
+_RandomAccessIterator_requirement_violation(_RandAccIter __i) {
+  // Refinement of BidirectionalIterator
+  _BidirectionalIterator_concept_specification<_RandAccIter>::
+    _BidirectionalIterator_requirement_violation(__i);
+  // Refinement of LessThanComparable
+  _LessThanComparable_concept_specification<_RandAccIter>::
+    _LessThanComparable_requirement_violation(__i);
+  typedef typename 
+        __value_type_type_definition_requirement_violation<_RandAccIter>
+        ::value_type
+    value_type;
+  typedef typename
+        __difference_type_type_definition_requirement_violation<_RandAccIter>
+        ::difference_type 
+    _Dist;
+  typedef typename _Mutable_trait<_Dist>::_Type _MutDist;
+
+  // Valid Expressions
+  _STL_ERROR::__iterator_addition_assignment_requirement_violation(__i,
+                                                                   _MutDist());
+  _STL_ERROR::__iterator_addition_requirement_violation(__i,
+                                                        _MutDist());
+  _STL_ERROR::
+    __iterator_subtraction_assignment_requirement_violation(__i,
+                                                            _MutDist());
+  _STL_ERROR::__iterator_subtraction_requirement_violation(__i,
+                                                           _MutDist());
+  _STL_ERROR::__difference_operator_requirement_violation(__i, __i,
+                                                          _MutDist());
+  typename _Mutable_trait<value_type>::_Type* __dummy_ptr = 0;
+  _STL_ERROR::__element_access_operator_requirement_violation(__i,
+                                                              __dummy_ptr,
+                                                              _MutDist());
+}
+};
+
+template <class _RandAccIter>
+struct _Mutable_RandomAccessIterator_concept_specification {
+static void
+_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i)
+{
+  _RandomAccessIterator_concept_specification<_RandAccIter>::
+    _RandomAccessIterator_requirement_violation(__i);
+  // Refinement of mutable_BidirectionalIterator
+  _Mutable_BidirectionalIterator_concept_specification<_RandAccIter>::
+    _Mutable_BidirectionalIterator_requirement_violation(__i);
+  typedef typename
+        __value_type_type_definition_requirement_violation<_RandAccIter>
+        ::value_type
+    value_type;
+  typedef typename
+        __difference_type_type_definition_requirement_violation<_RandAccIter>
+        ::difference_type
+    _Dist;
+
+  typename _Mutable_trait<value_type>::_Type* __tmp_ptr = 0;
+  // Valid Expressions
+  _STL_ERROR::__element_assignment_operator_requirement_violation(__i,
+                  __tmp_ptr, _Dist());
+}
+};
+
+#define __STL_TYPEDEF_REQUIREMENT(__REQUIREMENT) \
+template <class Type> \
+struct __##__REQUIREMENT##__typedef_requirement_violation { \
+  typedef typename Type::__REQUIREMENT __REQUIREMENT; \
+}
+
+__STL_TYPEDEF_REQUIREMENT(value_type);
+__STL_TYPEDEF_REQUIREMENT(difference_type);
+__STL_TYPEDEF_REQUIREMENT(size_type);
+__STL_TYPEDEF_REQUIREMENT(reference);
+__STL_TYPEDEF_REQUIREMENT(const_reference);
+__STL_TYPEDEF_REQUIREMENT(pointer);
+__STL_TYPEDEF_REQUIREMENT(const_pointer);
+
+
+template <class _Alloc>
+struct _Allocator_concept_specification {
+static void
+_Allocator_requirement_violation(_Alloc __a) {
+  // Refinement of DefaultConstructible
+  _DefaultConstructible_concept_specification<_Alloc>::
+    _DefaultConstructible_requirement_violation(__a);
+  // Refinement of EqualityComparable
+  _EqualityComparable_concept_specification<_Alloc>::
+    _EqualityComparable_requirement_violation(__a);
+  // Associated Types
+  __value_type__typedef_requirement_violation<_Alloc>();
+  __difference_type__typedef_requirement_violation<_Alloc>();
+  __size_type__typedef_requirement_violation<_Alloc>();
+  __reference__typedef_requirement_violation<_Alloc>();
+  __const_reference__typedef_requirement_violation<_Alloc>();
+  __pointer__typedef_requirement_violation<_Alloc>();
+  __const_pointer__typedef_requirement_violation<_Alloc>();
+  typedef typename _Alloc::value_type _Tp;
+  //__STL_REQUIRES_SAME_TYPE(typename _Alloc::__STL_TEMPLATE rebind<_Tp>::other,
+  //                         _Alloc);
+}
+};
+
+#endif /* __STL_USE_CONCEPT_CHECKS */
+
+#endif /* __CONCEPT_CHECKS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stl/cstring b/WebKit/android/stl/cstring
new file mode 100644
index 0000000..77c9175
--- /dev/null
+++ b/WebKit/android/stl/cstring
@@ -0,0 +1,128 @@
+// -*- C++ -*- forwarding header.
+
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
+// Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+//
+// ISO C++ 14882: 20.4.6  C library
+//
+
+/** @file cstring
+ *  This is a Standard C++ Library file.  You should @c #include this file
+ *  in your programs, rather than any of the "*.h" implementation files.
+ *
+ *  This is the C++ version of the Standard C Library header @c string.h,
+ *  and its contents are (mostly) the same as that header, but are all
+ *  contained in the namespace @c std.
+ */
+
+#ifndef _GLIBCXX_CSTRING
+#define _GLIBCXX_CSTRING 1
+
+#pragma GCC system_header
+
+#include <cstddef>
+
+#include <string.h>
+
+// Get rid of those macros defined in <string.h> in lieu of real functions.
+#undef memcpy
+#undef memmove
+#undef strcpy
+#undef strncpy
+#undef strcat
+#undef strncat
+#undef memcmp
+#undef strcmp
+#undef strcoll
+#undef strncmp
+#undef strxfrm
+#undef memchr
+#undef strchr
+#undef strcspn
+#undef strpbrk
+#undef strrchr
+#undef strspn
+#undef strstr
+#undef strtok
+#undef memset
+#undef strerror
+#undef strlen
+
+namespace std
+{
+  using ::memcpy;
+  using ::memmove;
+  using ::strcpy;
+  using ::strncpy;
+  using ::strcat;
+  using ::strncat;
+  using ::memcmp;
+  using ::strcmp;
+//  using ::strcoll;
+  using ::strncmp;
+//  using ::strxfrm;
+  using ::strcspn;
+  using ::strspn;
+  using ::strtok;
+  using ::memset;
+  using ::strerror;
+  using ::strlen;
+
+  using ::memchr;
+
+  inline void*
+  memchr(void* __p, int __c, size_t __n)
+  { return memchr(const_cast<const void*>(__p), __c, __n); }
+
+  using ::strchr;
+
+  inline char*
+  strchr(char* __s1, int __n)
+  { return __builtin_strchr(const_cast<const char*>(__s1), __n); }
+
+  using ::strpbrk;
+
+  inline char*
+  strpbrk(char* __s1, const char* __s2)
+  { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }
+
+  using ::strrchr;
+
+  inline char*
+  strrchr(char* __s1, int __n)
+  { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }
+
+  using ::strstr;
+
+  inline char*
+  strstr(char* __s1, const char* __s2)
+  { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
+}
+
+#endif
diff --git a/WebKit/android/stl/heap.h b/WebKit/android/stl/heap.h
new file mode 100644
index 0000000..d1fb319
--- /dev/null
+++ b/WebKit/android/stl/heap.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __SGI_STL_HEAP_H
+#define __SGI_STL_HEAP_H
+
+#include <concept_checks.h>
+#include <stl_config.h>
+#include <stl_heap.h>
+
+#ifdef __STL_USE_NAMESPACES
+
+using __STD::push_heap;
+using __STD::pop_heap;
+using __STD::make_heap;
+using __STD::sort_heap;
+
+#endif /* __STL_USE_NAMESPACES */
+
+
+#endif /* __SGI_STL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stl/iostream.h b/WebKit/android/stl/iostream.h
new file mode 100644
index 0000000..2b7d968
--- /dev/null
+++ b/WebKit/android/stl/iostream.h
@@ -0,0 +1 @@
+// this file intentionally left blank
diff --git a/WebKit/android/stl/limits b/WebKit/android/stl/limits
new file mode 100644
index 0000000..d4d7960
--- /dev/null
+++ b/WebKit/android/stl/limits
@@ -0,0 +1,23 @@
+/* 
+**
+** Copyright 2007, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef __ANDROID_LIMITS
+#define __ANDROID_LIMITS
+
+#include <limits.h>
+
+#endif // __ANDROID_LIMITS
diff --git a/WebKit/android/stl/memory b/WebKit/android/stl/memory
new file mode 100644
index 0000000..b224c33
--- /dev/null
+++ b/WebKit/android/stl/memory
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+//minimal file to get build to work
+
+#ifdef _CPP_MEMORY
+#error "real STL defined"
+#endif
+
+#ifndef __ANDROID_MEMORY
+#define __ANDROID_MEMORY
+//we good to do this?
+#define __STL_MEMBER_TEMPLATES
+
+#define __STL_NOTHROW
+
+/*#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \*/
+
+#if defined(__STL_MEMBER_TEMPLATES)
+template<class _Tp1> struct auto_ptr_ref {
+  _Tp1* _M_ptr;
+  auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
+};
+#endif
+
+namespace std {
+
+template <class _Tp> class auto_ptr {
+private:
+  _Tp* _M_ptr;
+
+public:
+  typedef _Tp element_type;
+
+  explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}
+  auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
+    : _M_ptr(__a.release()) {}
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {
+    if (&__a != this) {
+      delete _M_ptr;
+      _M_ptr = __a.release();
+    }
+    return *this;
+  }
+
+#ifdef __STL_MEMBER_TEMPLATES
+  template <class _Tp1>
+  auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {
+    if (__a.get() != this->get()) {
+      delete _M_ptr;
+      _M_ptr = __a.release();
+    }
+    return *this;
+  }
+#endif /* __STL_MEMBER_TEMPLATES */
+
+  // Note: The C++ standard says there is supposed to be an empty throw
+  // specification here, but omitting it is standard conforming.  Its 
+  // presence can be detected only if _Tp::~_Tp() throws, but (17.4.3.6/2)
+  // this is prohibited.
+  ~auto_ptr() { delete _M_ptr; }
+
+  _Tp& operator*() const __STL_NOTHROW {
+    return *_M_ptr;
+  }
+  _Tp* operator->() const __STL_NOTHROW {
+    return _M_ptr;
+  }
+  _Tp* get() const __STL_NOTHROW {
+    return _M_ptr;
+  }
+  _Tp* release() __STL_NOTHROW {
+    _Tp* __tmp = _M_ptr;
+    _M_ptr = 0;
+    return __tmp;
+  }
+  void reset(_Tp* __p = 0) __STL_NOTHROW {
+    if (__p != _M_ptr) {
+      delete _M_ptr;
+      _M_ptr = __p;
+    }
+  }
+
+/*#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && \*/
+#if defined(__STL_MEMBER_TEMPLATES)
+
+public:
+  auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW
+    : _M_ptr(__ref._M_ptr) {}
+
+  auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW {
+    if (__ref._M_ptr != this->get()) {
+      delete _M_ptr;
+      _M_ptr = __ref._M_ptr;
+    }
+    return *this;
+  }
+
+  template <class _Tp1> operator auto_ptr_ref<_Tp1>() __STL_NOTHROW 
+    { return auto_ptr_ref<_Tp1>(this->release()); }
+  template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW
+    { return auto_ptr<_Tp1>(this->release()); }
+
+#endif /* auto ptr conversions && member templates */
+
+};
+
+}   //namespace std
+
+#endif /* __ANDROID_MEMORY */
+
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/WebKit/android/stl/new.h b/WebKit/android/stl/new.h
new file mode 100644
index 0000000..13d6d4e
--- /dev/null
+++ b/WebKit/android/stl/new.h
@@ -0,0 +1,17 @@
+/* 
+**
+** Copyright 2007, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
diff --git a/WebKit/android/stl/stl_config.h b/WebKit/android/stl/stl_config.h
new file mode 100644
index 0000000..8c107c1
--- /dev/null
+++ b/WebKit/android/stl/stl_config.h
@@ -0,0 +1,576 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef __STL_CONFIG_H
+# define __STL_CONFIG_H
+
+// Flags:
+// * __STL_NO_BOOL: defined if the compiler doesn't have bool as a builtin
+//   type.
+// * __STL_HAS_WCHAR_T: defined if the compier has wchar_t as a builtin type.
+// * __STL_NO_DRAND48: defined if the compiler doesn't have the drand48 
+//   function.
+// * __STL_STATIC_TEMPLATE_MEMBER_BUG: defined if the compiler can't handle
+//   static members of template classes.
+// * __STL_STATIC_CONST_INIT_BUG: defined if the compiler can't handle a
+//   constant-initializer in the declaration of a static const data member
+//   of integer type.  (See section 9.4.2, paragraph 4, of the C++ standard.)
+// * __STL_CLASS_PARTIAL_SPECIALIZATION: defined if the compiler supports
+//   partial specialization of template classes.
+// * __STL_PARTIAL_SPECIALIZATION_SYNTAX: defined if the compiler 
+//   supports partial specialization syntax for full specialization of
+//   class templates.  (Even if it doesn't actually support partial 
+//   specialization itself.)
+// * __STL_FUNCTION_TMPL_PARTIAL_ORDER: defined if the compiler supports
+//   partial ordering of function templates.  (a.k.a partial specialization
+//   of function templates.)
+// * __STL_MEMBER_TEMPLATES: defined if the compiler supports template
+//   member functions of classes.
+// * __STL_MEMBER_TEMPLATE_CLASSES: defined if the compiler supports 
+//   nested classes that are member templates of other classes.
+// * __STL_TEMPLATE_FRIENDS: defined if the compiler supports templatized
+//   friend declarations.
+// * __STL_EXPLICIT_FUNCTION_TMPL_ARGS: defined if the compiler 
+//   supports calling a function template by providing its template
+//   arguments explicitly.
+// * __STL_LIMITED_DEFAULT_TEMPLATES: defined if the compiler is unable
+//   to handle default template parameters that depend on previous template
+//   parameters.
+// * __STL_NON_TYPE_TMPL_PARAM_BUG: defined if the compiler has trouble with
+//   function template argument deduction for non-type template parameters.
+// * __SGI_STL_NO_ARROW_OPERATOR: defined if the compiler is unable
+//   to support the -> operator for iterators.
+// * __STL_DEFAULT_CONSTRUCTOR_BUG: defined if T() does not work properly
+//   when T is a builtin type.
+// * __STL_USE_EXCEPTIONS: defined if the compiler (in the current compilation
+//   mode) supports exceptions.
+// * __STL_USE_NAMESPACES: defined if the compiler has the necessary
+//   support for namespaces.
+// * __STL_NO_EXCEPTION_HEADER: defined if the compiler does not have a
+//   standard-conforming header <exception>.
+// * __STL_NO_BAD_ALLOC: defined if the compiler does not have a <new>
+//   header, or if <new> does not contain a bad_alloc class.  If a bad_alloc
+//   class exists, it is assumed to be in namespace std.
+// * __STL_SGI_THREADS: defined if this is being compiled for an SGI IRIX
+//   system in multithreaded mode, using native SGI threads instead of 
+//   pthreads.
+// * __STL_WIN32THREADS: defined if this is being compiled on a WIN32
+//   compiler in multithreaded mode.
+// * __STL_PTHREADS: defined if we should use portable pthreads
+//   synchronization.
+// * __STL_UITHREADS: defined if we should use UI / solaris / UnixWare threads
+//   synchronization.  UIthreads are similar to pthreads, but are based 
+//   on an earlier version of the Posix threads standard.
+// * __STL_LONG_LONG if the compiler has long long and unsigned long long
+//   types.  (They're not in the C++ standard, but they are expected to be 
+//   included in the forthcoming C9X standard.)
+// * __STL_THREADS is defined if thread safety is needed.
+// * __STL_VOLATILE is defined to be "volatile" if threads are being
+//   used, and the empty string otherwise.
+// * __STL_USE_CONCEPT_CHECKS enables some extra compile-time error
+//   checking to make sure that user-defined template arguments satisfy
+//   all of the appropriate requirements.  This may result in more
+//   comprehensible error messages.  It incurs no runtime overhead.  This 
+//   feature requires member templates and partial specialization.
+// * __STL_NO_USING_CLAUSE_IN_CLASS: The compiler does not handle "using"
+//   clauses inside of class definitions.
+// * __STL_NO_FRIEND_TEMPLATE_CLASS: The compiler does not handle friend
+//   declaractions where the friend is a template class.
+// * __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE: The compiler does not
+//   support the use of a function pointer type as the argument
+//   for a template.
+// * __STL_MEMBER_TEMPLATE_KEYWORD: standard C++ requires the template
+//   keyword in a few new places (14.2.4).  This flag is set for
+//   compilers that support (and require) this usage.
+
+
+// User-settable macros that control compilation:
+// * __STL_USE_SGI_ALLOCATORS: if defined, then the STL will use older
+//   SGI-style allocators, instead of standard-conforming allocators,
+//   even if the compiler supports all of the language features needed
+//   for standard-conforming allocators.
+// * __STL_NO_NAMESPACES: if defined, don't put the library in namespace
+//   std, even if the compiler supports namespaces.
+// * __STL_NO_RELOPS_NAMESPACE: if defined, don't put the relational
+//   operator templates (>, <=. >=, !=) in namespace std::rel_ops, even
+//   if the compiler supports namespaces and partial ordering of
+//   function templates.
+// * __STL_ASSERTIONS: if defined, then enable runtime checking through the
+//   __stl_assert macro.
+// * _PTHREADS: if defined, use Posix threads for multithreading support.
+// * _UITHREADS:if defined, use SCO/Solaris/UI threads for multithreading 
+//   support
+// * _NOTHREADS: if defined, don't use any multithreading support.  
+// * _STL_NO_CONCEPT_CHECKS: if defined, disables the error checking that
+//   we get from __STL_USE_CONCEPT_CHECKS.
+// * __STL_USE_NEW_IOSTREAMS: if defined, then the STL will use new,
+//   standard-conforming iostreams (e.g. the <iosfwd> header).  If not
+//   defined, the STL will use old cfront-style iostreams (e.g. the
+//   <iostream.h> header).
+
+// Other macros defined by this file:
+
+// * bool, true, and false, if __STL_NO_BOOL is defined.
+// * typename, as a null macro if it's not already a keyword.
+// * explicit, as a null macro if it's not already a keyword.
+// * namespace-related macros (__STD, __STL_BEGIN_NAMESPACE, etc.)
+// * exception-related macros (__STL_TRY, __STL_UNWIND, etc.)
+// * __stl_assert, either as a test or as a null macro, depending on
+//   whether or not __STL_ASSERTIONS is defined.
+
+# if defined(_PTHREADS) && !defined(_NOTHREADS)
+#     define __STL_PTHREADS
+# endif
+
+# if defined(_UITHREADS) && !defined(_PTHREADS) && !defined(_NOTHREADS)
+#     define __STL_UITHREADS
+# endif
+
+# if defined(__sgi) && !defined(__GNUC__)
+#   include <standards.h>
+#   if !defined(_BOOL)
+#     define __STL_NO_BOOL
+#   endif
+#   if defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32
+#     define __STL_STATIC_CONST_INIT_BUG
+#   endif
+#   if defined(_WCHAR_T_IS_KEYWORD)
+#     define __STL_HAS_WCHAR_T 
+#   endif
+#   if !defined(_TYPENAME_IS_KEYWORD)
+#     define __STL_NEED_TYPENAME
+#   endif
+#   ifdef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#   endif
+#   if (_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32
+#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#   endif
+#   ifdef _MEMBER_TEMPLATES
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_TEMPLATE_FRIENDS
+#     define __STL_MEMBER_TEMPLATE_CLASSES
+#   endif
+#   if defined(_MEMBER_TEMPLATE_KEYWORD)
+#     define __STL_MEMBER_TEMPLATE_KEYWORD
+#   endif
+#   if defined(_STANDARD_C_PLUS_PLUS)
+#     define __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#   endif
+#   if (_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32
+#     define __STL_MEMBER_TEMPLATE_KEYWORD
+#   endif
+#   if COMPILER_VERSION < 720 || (defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32)
+#     define __STL_DEFAULT_CONSTRUCTOR_BUG
+#   endif
+#   if !defined(_EXPLICIT_IS_KEYWORD)
+#     define __STL_NEED_EXPLICIT
+#   endif
+#   ifdef __EXCEPTIONS
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   if (_COMPILER_VERSION >= 721) && defined(_NAMESPACES)
+#     define __STL_HAS_NAMESPACES
+#   endif 
+#   if (_COMPILER_VERSION < 721) || \
+    !defined(__STL_HAS_NAMESPACES) || defined(__STL_NO_NAMESPACES)
+#     define __STL_NO_EXCEPTION_HEADER
+#   endif
+#   if _COMPILER_VERSION < 730 || !defined(_STANDARD_C_PLUS_PLUS) || \
+      !defined(_NAMESPACES)
+#     define __STL_NO_BAD_ALLOC
+#   endif
+#   if !defined(_NOTHREADS) && !defined(__STL_PTHREADS)
+#     define __STL_SGI_THREADS
+#   endif
+#   if defined(_LONGLONG) && defined(_SGIAPI) && _SGIAPI
+#     define __STL_LONG_LONG
+#   endif
+#   if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)
+#     define __STL_USE_NEW_IOSTREAMS
+#   endif
+#   if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)
+#     define __STL_CAN_THROW_RANGE_ERRORS
+#   endif
+#   if _COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS)
+#     define __SGI_STL_USE_AUTO_PTR_CONVERSIONS
+#   endif
+# endif
+
+
+/*
+ * Jochen Schlick '1999  - added new #defines (__STL)_UITHREADS (for 
+ *                         providing SCO / Solaris / UI thread support)
+ *                       - added the necessary defines for the SCO UDK 7 
+ *                         compiler (and its template friend behavior)
+ *                       - all UDK7 specific STL changes are based on the 
+ *                         macro __USLC__ being defined
+ */
+// SCO UDK 7 compiler (UnixWare 7x, OSR 5, UnixWare 2x)
+# if defined(__USLC__)
+#     define __STL_HAS_WCHAR_T 
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#     define __STL_PARTIAL_SPECIALIZATION_SYNTAX
+#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_MEMBER_TEMPLATE_CLASSES
+#     define __STL_USE_EXCEPTIONS
+#     define __STL_HAS_NAMESPACES
+#     define __STL_USE_NAMESPACES
+#     define __STL_LONG_LONG
+#     if defined(_REENTRANT)
+#           define _UITHREADS     /* if      UnixWare < 7.0.1 */
+#           define __STL_UITHREADS
+//   use the following defines instead of the UI threads defines when
+//   you want to use POSIX threads
+//#         define _PTHREADS      /* only if UnixWare >=7.0.1 */
+//#         define __STL_PTHREADS
+#     endif
+# endif
+
+
+
+# ifdef __GNUC__
+#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 7
+#     define __STL_STATIC_TEMPLATE_MEMBER_BUG
+#   endif
+#   if __GNUC__ < 2 
+#     define __STL_NEED_TYPENAME
+#     define __STL_NEED_EXPLICIT
+#   endif
+#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
+#     define __STL_NO_EXCEPTION_HEADER
+#     define __STL_NO_BAD_ALLOC
+#   endif
+#   if __GNUC__ == 2 && __GNUC_MINOR__ >= 8 || __GNUC__ > 2
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#     define __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_CAN_THROW_RANGE_ERRORS
+      //    g++ 2.8.1 supports member template functions, but not member
+      //    template nested classes.
+#     if __GNUC_MINOR__ >= 9 || __GNUC__ > 2
+#       define __STL_MEMBER_TEMPLATE_CLASSES
+#       define __STL_TEMPLATE_FRIENDS
+#       define __SGI_STL_USE_AUTO_PTR_CONVERSIONS
+#       define __STL_HAS_NAMESPACES
+//#       define __STL_USE_NEW_IOSTREAMS
+#     endif
+#   endif
+#   define __STL_DEFAULT_CONSTRUCTOR_BUG
+#   ifdef __EXCEPTIONS
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef _REENTRANT
+#     define __STL_PTHREADS
+#   endif
+#   if (__GNUC__ < 2) || (__GNUC__ == 2 && __GNUC_MINOR__ < 95)
+#     define __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
+#   endif
+# endif
+
+# if defined(__SUNPRO_CC) 
+#   define __STL_NO_BOOL
+#   define __STL_NEED_TYPENAME
+#   define __STL_NEED_EXPLICIT
+#   define __STL_USE_EXCEPTIONS
+#   ifdef _REENTRANT
+#     define __STL_PTHREADS
+#   endif
+#   define __SGI_STL_NO_ARROW_OPERATOR
+#   define __STL_PARTIAL_SPECIALIZATION_SYNTAX
+#   define __STL_NO_EXCEPTION_HEADER
+#   define __STL_NO_BAD_ALLOC
+# endif
+
+# if defined(__COMO__)
+#   define __STL_MEMBER_TEMPLATES
+#   define __STL_MEMBER_TEMPLATE_CLASSES
+#   define __STL_TEMPLATE_FRIENDS
+#   define __STL_CLASS_PARTIAL_SPECIALIZATION
+#   define __STL_USE_EXCEPTIONS
+#   define __STL_HAS_NAMESPACES
+# endif
+
+// Intel compiler, which uses the EDG front end.
+# if defined(__ICL)
+#   define __STL_LONG_LONG 
+#   define __STL_MEMBER_TEMPLATES
+#   define __STL_MEMBER_TEMPLATE_CLASSES
+#   define __STL_TEMPLATE_FRIENDS
+#   define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#   define __STL_CLASS_PARTIAL_SPECIALIZATION
+#   define __STL_NO_DRAND48
+#   define __STL_HAS_NAMESPACES
+#   define __STL_USE_EXCEPTIONS
+#   define __STL_MEMBER_TEMPLATE_KEYWORD
+#   ifdef _CPPUNWIND
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef _MT
+#     define __STL_WIN32THREADS
+#   endif
+# endif
+
+// Mingw32, egcs compiler using the Microsoft C runtime
+# if defined(__MINGW32__)
+#   define __STL_NO_DRAND48
+#   ifdef _MT
+#     define __STL_WIN32THREADS
+#   endif
+# endif
+
+// Cygwin32, egcs compiler on MS Windows
+# if defined(__CYGWIN__)
+#   define __STL_NO_DRAND48
+# endif
+
+
+
+// Microsoft compiler.
+# if defined(_MSC_VER) && !defined(__ICL) && !defined(__MWERKS__)
+#   define __STL_NO_DRAND48
+#   define __STL_STATIC_CONST_INIT_BUG
+#   define __STL_NEED_TYPENAME
+#   define __STL_NO_USING_CLAUSE_IN_CLASS
+#   define __STL_NO_FRIEND_TEMPLATE_CLASS
+#   if _MSC_VER < 1100  /* 1000 is version 4.0, 1100 is 5.0, 1200 is 6.0. */
+#     define __STL_NEED_EXPLICIT
+#     define __STL_NO_BOOL
+#     define __STL_NO_BAD_ALLOC
+#   endif
+#   if _MSC_VER > 1000
+#     include <yvals.h>
+#     define __STL_DONT_USE_BOOL_TYPEDEF
+#   endif
+#   define __STL_NON_TYPE_TMPL_PARAM_BUG
+#   define __SGI_STL_NO_ARROW_OPERATOR
+#   define __STL_DEFAULT_CONSTRUCTOR_BUG
+#   ifdef _CPPUNWIND
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef _MT
+#     define __STL_WIN32THREADS
+#   endif
+#   if _MSC_VER >= 1200
+#     define __STL_PARTIAL_SPECIALIZATION_SYNTAX
+#     define __STL_HAS_NAMESPACES
+#     define __STL_CAN_THROW_RANGE_ERRORS
+#     define NOMINMAX
+#     undef min
+#     undef max
+// disable warning 'initializers put in unrecognized initialization area'
+#     pragma warning ( disable : 4075 )
+// disable warning 'empty controlled statement found'
+#     pragma warning ( disable : 4390 )
+// disable warning 'debug symbol greater than 255 chars'
+#     pragma warning ( disable : 4786 )
+#   endif
+#   if _MSC_VER < 1100
+#     define __STL_NO_EXCEPTION_HEADER
+#     define __STL_NO_BAD_ALLOC
+#   endif
+    // Because of a Microsoft front end bug, we must not provide a
+    // namespace qualifier when declaring a friend function.
+#   define __STD_QUALIFIER
+# endif
+
+# if defined(__BORLANDC__)
+#     define __STL_NO_BAD_ALLOC
+#     define __STL_NO_DRAND48
+#     define __STL_DEFAULT_CONSTRUCTOR_BUG
+#   if __BORLANDC__ >= 0x540 /* C++ Builder 4.0 */
+#     define __STL_CLASS_PARTIAL_SPECIALIZATION
+#     define __STL_FUNCTION_TMPL_PARTIAL_ORDER
+#     define __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#     define __STL_MEMBER_TEMPLATES
+#     define __STL_TEMPLATE_FRIENDS
+#   else
+#     define __STL_NEED_TYPENAME
+#     define __STL_LIMITED_DEFAULT_TEMPLATES
+#     define __SGI_STL_NO_ARROW_OPERATOR
+#     define __STL_NON_TYPE_TMPL_PARAM_BUG
+#   endif
+#   ifdef _CPPUNWIND
+#     define __STL_USE_EXCEPTIONS
+#   endif
+#   ifdef __MT__
+#     define __STL_WIN32THREADS
+#   endif
+# endif
+
+# if defined(__STL_NO_BOOL) && !defined(__STL_DONT_USE_BOOL_TYPEDEF)
+    typedef int bool;
+#   define true 1
+#   define false 0
+# endif
+
+# ifdef __STL_NEED_TYPENAME
+#   define typename
+# endif
+
+# ifdef __STL_LIMITED_DEFAULT_TEMPLATES
+#   define __STL_DEPENDENT_DEFAULT_TMPL(_Tp)
+# else
+#   define __STL_DEPENDENT_DEFAULT_TMPL(_Tp) = _Tp
+# endif
+
+# ifdef __STL_MEMBER_TEMPLATE_KEYWORD
+#   define __STL_TEMPLATE template
+# else
+#   define __STL_TEMPLATE
+# endif
+
+# ifdef __STL_NEED_EXPLICIT
+#   define explicit
+# endif
+
+# ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS
+#   define __STL_NULL_TMPL_ARGS <>
+# else
+#   define __STL_NULL_TMPL_ARGS
+# endif
+
+# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) \
+     || defined (__STL_PARTIAL_SPECIALIZATION_SYNTAX)
+#   define __STL_TEMPLATE_NULL template<>
+# else
+#   define __STL_TEMPLATE_NULL
+# endif
+
+// Use standard-conforming allocators if we have the necessary language
+// features.  __STL_USE_SGI_ALLOCATORS is a hook so that users can 
+// disable new-style allocators, and continue to use the same kind of
+// allocators as before, without having to edit library headers.
+# if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && \
+     defined(__STL_MEMBER_TEMPLATES) && \
+     defined(__STL_MEMBER_TEMPLATE_CLASSES) && \
+    !defined(__STL_NO_BOOL) && \
+    !defined(__STL_NON_TYPE_TMPL_PARAM_BUG) && \
+    !defined(__STL_LIMITED_DEFAULT_TEMPLATES) && \
+    !defined(__STL_USE_SGI_ALLOCATORS) 
+#   define __STL_USE_STD_ALLOCATORS
+# endif
+
+# ifndef __STL_DEFAULT_ALLOCATOR
+#   ifdef __STL_USE_STD_ALLOCATORS
+#     define __STL_DEFAULT_ALLOCATOR(T) allocator< T >
+#   else
+#     define __STL_DEFAULT_ALLOCATOR(T) alloc
+#   endif
+# endif
+
+// __STL_NO_NAMESPACES is a hook so that users can disable namespaces
+// without having to edit library headers.  __STL_NO_RELOPS_NAMESPACE is
+// a hook so that users can disable the std::rel_ops namespace, keeping 
+// the relational operator template in namespace std, without having to 
+// edit library headers.
+# if defined(__STL_HAS_NAMESPACES) && !defined(__STL_NO_NAMESPACES)
+#   define __STL_USE_NAMESPACES
+#   define __STD std
+#   define __STL_BEGIN_NAMESPACE namespace std {
+#   define __STL_END_NAMESPACE }
+#   if defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) && \
+       !defined(__STL_NO_RELOPS_NAMESPACE)
+#     define __STL_USE_NAMESPACE_FOR_RELOPS
+#     define __STL_BEGIN_RELOPS_NAMESPACE namespace std { namespace rel_ops {
+#     define __STL_END_RELOPS_NAMESPACE } }
+#     define __STD_RELOPS std::rel_ops
+#   else /* Use std::rel_ops namespace */
+#     define __STL_USE_NAMESPACE_FOR_RELOPS
+#     define __STL_BEGIN_RELOPS_NAMESPACE namespace std {
+#     define __STL_END_RELOPS_NAMESPACE }
+#     define __STD_RELOPS std
+#   endif /* Use std::rel_ops namespace */
+# else
+#   define __STD 
+#   define __STL_BEGIN_NAMESPACE 
+#   define __STL_END_NAMESPACE 
+#   undef  __STL_USE_NAMESPACE_FOR_RELOPS
+#   define __STL_BEGIN_RELOPS_NAMESPACE 
+#   define __STL_END_RELOPS_NAMESPACE 
+#   define __STD_RELOPS 
+#   undef  __STL_USE_NAMESPACES
+# endif
+
+// Some versions of the EDG front end sometimes require an explicit
+// namespace spec where they shouldn't.  This macro facilitates that.
+// If the bug becomes irrelevant, then all uses of __STD_QUALIFIER
+// should be removed.  The 7.3 beta SGI compiler has this bug, but the
+// MR version is not expected to have it.
+
+# if defined(__STL_USE_NAMESPACES) && !defined(__STD_QUALIFIER)
+#   define __STD_QUALIFIER std::
+# else
+#   define __STD_QUALIFIER
+# endif
+
+# ifdef __STL_USE_EXCEPTIONS
+#   define __STL_TRY try
+#   define __STL_CATCH_ALL catch(...)
+#   define __STL_THROW(x) throw x
+#   define __STL_RETHROW throw
+#   define __STL_NOTHROW throw()
+#   define __STL_UNWIND(action) catch(...) { action; throw; }
+# else
+#   define __STL_TRY 
+#   define __STL_CATCH_ALL if (false)
+#   define __STL_THROW(x) 
+#   define __STL_RETHROW 
+#   define __STL_NOTHROW 
+#   define __STL_UNWIND(action) 
+# endif
+
+#ifdef __STL_ASSERTIONS
+# include <stdio.h>
+# define __stl_assert(expr) \
+    if (!(expr)) { fprintf(stderr, "%s:%d STL assertion failure: %s\n", \
+			  __FILE__, __LINE__, # expr); abort(); }
+#else
+# define __stl_assert(expr)
+#endif
+
+#if defined(__STL_WIN32THREADS) || defined(__STL_SGI_THREADS) \
+    || defined(__STL_PTHREADS)  || defined(__STL_UITHREADS)
+#   define __STL_THREADS
+#   define __STL_VOLATILE volatile
+#else
+#   define __STL_VOLATILE
+#endif
+
+#if defined(__STL_CLASS_PARTIAL_SPECIALIZATION) \
+    && defined(__STL_MEMBER_TEMPLATES) \
+    && !defined(_STL_NO_CONCEPT_CHECKS)
+#  define __STL_USE_CONCEPT_CHECKS
+#endif
+
+
+#endif /* __STL_CONFIG_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stl/stl_heap.h b/WebKit/android/stl/stl_heap.h
new file mode 100644
index 0000000..651d21a
--- /dev/null
+++ b/WebKit/android/stl/stl_heap.h
@@ -0,0 +1,297 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_HEAP_H
+#define __SGI_STL_INTERNAL_HEAP_H
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1209
+#endif
+
+// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap.
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void 
+__push_heap(_RandomAccessIterator __first,
+            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }    
+  *(__first + __holeIndex) = __value;
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+inline void 
+__push_heap_aux(_RandomAccessIterator __first,
+                _RandomAccessIterator __last, _Distance*, _Tp*)
+{
+  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
+              _Tp(*(__last - 1)));
+}
+
+template <class _RandomAccessIterator>
+inline void 
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
+                 _LessThanComparable);
+  __push_heap_aux(__first, __last,
+                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp, 
+          class _Compare>
+void
+__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+            _Distance __topIndex, _Tp __value, _Compare __comp)
+{
+  _Distance __parent = (__holeIndex - 1) / 2;
+  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
+    *(__first + __holeIndex) = *(__first + __parent);
+    __holeIndex = __parent;
+    __parent = (__holeIndex - 1) / 2;
+  }
+  *(__first + __holeIndex) = __value;
+}
+
+template <class _RandomAccessIterator, class _Compare,
+          class _Distance, class _Tp>
+inline void 
+__push_heap_aux(_RandomAccessIterator __first,
+                _RandomAccessIterator __last, _Compare __comp,
+                _Distance*, _Tp*) 
+{
+  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
+              _Tp(*(__last - 1)), __comp);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+          _Compare __comp)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __push_heap_aux(__first, __last, __comp,
+                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void 
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __value)
+{
+  _Distance __topIndex = __holeIndex;
+  _Distance __secondChild = 2 * __holeIndex + 2;
+  while (__secondChild < __len) {
+    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
+      __secondChild--;
+    *(__first + __holeIndex) = *(__first + __secondChild);
+    __holeIndex = __secondChild;
+    __secondChild = 2 * (__secondChild + 1);
+  }
+  if (__secondChild == __len) {
+    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+    __holeIndex = __secondChild - 1;
+  }
+  __push_heap(__first, __holeIndex, __topIndex, __value);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+inline void 
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __value, _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
+}
+
+template <class _RandomAccessIterator, class _Tp>
+inline void 
+__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               _Tp*)
+{
+  __pop_heap(__first, __last - 1, __last - 1, 
+             _Tp(*(__last - 1)), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator>
+inline void pop_heap(_RandomAccessIterator __first, 
+                     _RandomAccessIterator __last)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
+                 _LessThanComparable);
+  __pop_heap_aux(__first, __last, __VALUE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Distance,
+          class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+              _Distance __len, _Tp __value, _Compare __comp)
+{
+  _Distance __topIndex = __holeIndex;
+  _Distance __secondChild = 2 * __holeIndex + 2;
+  while (__secondChild < __len) {
+    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
+      __secondChild--;
+    *(__first + __holeIndex) = *(__first + __secondChild);
+    __holeIndex = __secondChild;
+    __secondChild = 2 * (__secondChild + 1);
+  }
+  if (__secondChild == __len) {
+    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+    __holeIndex = __secondChild - 1;
+  }
+  __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Compare, 
+          class _Distance>
+inline void 
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           _RandomAccessIterator __result, _Tp __value, _Compare __comp,
+           _Distance*)
+{
+  *__result = *__first;
+  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), 
+                __value, __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Compare>
+inline void 
+__pop_heap_aux(_RandomAccessIterator __first,
+               _RandomAccessIterator __last, _Tp*, _Compare __comp)
+{
+  __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
+             __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+pop_heap(_RandomAccessIterator __first,
+         _RandomAccessIterator __last, _Compare __comp)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __pop_heap_aux(__first, __last, __VALUE_TYPE(__first), __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+void 
+__make_heap(_RandomAccessIterator __first,
+            _RandomAccessIterator __last, _Tp*, _Distance*)
+{
+  if (__last - __first < 2) return;
+  _Distance __len = __last - __first;
+  _Distance __parent = (__len - 2)/2;
+    
+  while (true) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator>
+inline void 
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
+                 _LessThanComparable);
+  __make_heap(__first, __last,
+              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator, class _Compare,
+          class _Tp, class _Distance>
+void
+__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+            _Compare __comp, _Tp*, _Distance*)
+{
+  if (__last - __first < 2) return;
+  _Distance __len = __last - __first;
+  _Distance __parent = (__len - 2)/2;
+    
+  while (true) {
+    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
+                  __comp);
+    if (__parent == 0) return;
+    __parent--;
+  }
+}
+
+template <class _RandomAccessIterator, class _Compare>
+inline void 
+make_heap(_RandomAccessIterator __first, 
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __make_heap(__first, __last, __comp,
+              __VALUE_TYPE(__first), __DISTANCE_TYPE(__first));
+}
+
+template <class _RandomAccessIterator>
+void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  __STL_REQUIRES(typename iterator_traits<_RandomAccessIterator>::value_type,
+                 _LessThanComparable);
+  while (__last - __first > 1)
+    pop_heap(__first, __last--);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void 
+sort_heap(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
+  while (__last - __first > 1)
+    pop_heap(__first, __last--, __comp);
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1209
+#endif
+
+__STL_END_NAMESPACE
+
+#endif /* __SGI_STL_INTERNAL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stl/stl_iterator_base.h b/WebKit/android/stl/stl_iterator_base.h
new file mode 100644
index 0000000..d03332b
--- /dev/null
+++ b/WebKit/android/stl/stl_iterator_base.h
@@ -0,0 +1,273 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ *   You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_ITERATOR_BASE_H
+#define __SGI_STL_INTERNAL_ITERATOR_BASE_H
+
+// This file contains all of the general iterator-related utilities.
+// The internal file stl_iterator.h contains predefined iterators, 
+// such as front_insert_iterator and istream_iterator.
+
+#include <concept_checks.h>
+
+struct input_iterator_tag {};
+struct output_iterator_tag {};
+struct forward_iterator_tag : public input_iterator_tag {};
+struct bidirectional_iterator_tag : public forward_iterator_tag {};
+struct random_access_iterator_tag : public bidirectional_iterator_tag {};
+
+// The base classes input_iterator, output_iterator, forward_iterator,
+// bidirectional_iterator, and random_access_iterator are not part of
+// the C++ standard.  (They have been replaced by struct iterator.)
+// They are included for backward compatibility with the HP STL.
+
+template <class _Tp, class _Distance> struct input_iterator {
+  typedef input_iterator_tag iterator_category;
+  typedef _Tp                value_type;
+  typedef _Distance          difference_type;
+  typedef _Tp*               pointer;
+  typedef _Tp&               reference;
+};
+
+struct output_iterator {
+  typedef output_iterator_tag iterator_category;
+  typedef void                value_type;
+  typedef void                difference_type;
+  typedef void                pointer;
+  typedef void                reference;
+};
+
+template <class _Tp, class _Distance> struct forward_iterator {
+  typedef forward_iterator_tag iterator_category;
+  typedef _Tp                  value_type;
+  typedef _Distance            difference_type;
+  typedef _Tp*                 pointer;
+  typedef _Tp&                 reference;
+};
+
+
+template <class _Tp, class _Distance> struct bidirectional_iterator {
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Tp&                       reference;
+};
+
+template <class _Tp, class _Distance> struct random_access_iterator {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                        value_type;
+  typedef _Distance                  difference_type;
+  typedef _Tp*                       pointer;
+  typedef _Tp&                       reference;
+};
+
+template <class _Category, class _Tp, class _Distance = ptrdiff_t,
+          class _Pointer = _Tp*, class _Reference = _Tp&>
+struct iterator {
+  typedef _Category  iterator_category;
+  typedef _Tp        value_type;
+  typedef _Distance  difference_type;
+  typedef _Pointer   pointer;
+  typedef _Reference reference;
+};
+
+template <class _Iterator>
+struct iterator_traits {
+  typedef typename _Iterator::iterator_category iterator_category;
+  typedef typename _Iterator::value_type        value_type;
+  typedef typename _Iterator::difference_type   difference_type;
+  typedef typename _Iterator::pointer           pointer;
+  typedef typename _Iterator::reference         reference;
+};
+
+template <class _Tp>
+struct iterator_traits<_Tp*> {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                         value_type;
+  typedef ptrdiff_t                   difference_type;
+  typedef _Tp*                        pointer;
+  typedef _Tp&                        reference;
+};
+
+template <class _Tp>
+struct iterator_traits<const _Tp*> {
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Tp                         value_type;
+  typedef ptrdiff_t                   difference_type;
+  typedef const _Tp*                  pointer;
+  typedef const _Tp&                  reference;
+};
+
+// The overloaded functions iterator_category, distance_type, and
+// value_type are not part of the C++ standard.  (They have been
+// replaced by struct iterator_traits.)  They are included for
+// backward compatibility with the HP STL.
+
+// We introduce internal names for these functions.
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+__iterator_category(const _Iter&)
+{
+  typedef typename iterator_traits<_Iter>::iterator_category _Category;
+  return _Category();
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+__distance_type(const _Iter&)
+{
+  return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+__value_type(const _Iter&)
+{
+  return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
+}
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::iterator_category
+iterator_category(const _Iter& __i) { return __iterator_category(__i); }
+
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::difference_type*
+distance_type(const _Iter& __i) { return __distance_type(__i); }
+
+template <class _Iter>
+inline typename iterator_traits<_Iter>::value_type*
+value_type(const _Iter& __i) { return __value_type(__i); }
+
+#define __ITERATOR_CATEGORY(__i) __iterator_category(__i)
+#define __DISTANCE_TYPE(__i)     __distance_type(__i)
+#define __VALUE_TYPE(__i)        __value_type(__i)
+
+template <class _InputIterator, class _Distance>
+inline void __distance(_InputIterator __first, _InputIterator __last,
+                       _Distance& __n, input_iterator_tag)
+{
+  while (__first != __last) { ++__first; ++__n; }
+}
+
+template <class _RandomAccessIterator, class _Distance>
+inline void __distance(_RandomAccessIterator __first, 
+                       _RandomAccessIterator __last, 
+                       _Distance& __n, random_access_iterator_tag)
+{
+  __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
+  __n += __last - __first;
+}
+
+template <class _InputIterator, class _Distance>
+inline void distance(_InputIterator __first, 
+                     _InputIterator __last, _Distance& __n)
+{
+  __STL_REQUIRES(_InputIterator, _InputIterator);
+  __distance(__first, __last, __n, iterator_category(__first));
+}
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
+{
+  typename iterator_traits<_InputIterator>::difference_type __n = 0;
+  while (__first != __last) {
+    ++__first; ++__n;
+  }
+  return __n;
+}
+
+template <class _RandomAccessIterator>
+inline typename iterator_traits<_RandomAccessIterator>::difference_type
+__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+           random_access_iterator_tag) {
+  __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
+  return __last - __first;
+}
+
+template <class _InputIterator>
+inline typename iterator_traits<_InputIterator>::difference_type
+distance(_InputIterator __first, _InputIterator __last) {
+  typedef typename iterator_traits<_InputIterator>::iterator_category 
+    _Category;
+  __STL_REQUIRES(_InputIterator, _InputIterator);
+  return __distance(__first, __last, _Category());
+}
+
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _InputIter, class _Distance>
+inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
+  while (__n--) ++__i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1183
+#endif
+
+template <class _BidirectionalIterator, class _Distance>
+inline void __advance(_BidirectionalIterator& __i, _Distance __n, 
+                      bidirectional_iterator_tag) {
+  __STL_REQUIRES(_BidirectionalIterator, _BidirectionalIterator);
+  if (__n >= 0)
+    while (__n--) ++__i;
+  else
+    while (__n++) --__i;
+}
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma reset woff 1183
+#endif
+
+template <class _RandomAccessIterator, class _Distance>
+inline void __advance(_RandomAccessIterator& __i, _Distance __n, 
+                      random_access_iterator_tag) {
+  __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
+  __i += __n;
+}
+
+template <class _InputIterator, class _Distance>
+inline void advance(_InputIterator& __i, _Distance __n) {
+  __STL_REQUIRES(_InputIterator, _InputIterator);
+  __advance(__i, __n, iterator_category(__i));
+}
+
+#endif /* __SGI_STL_INTERNAL_ITERATOR_BASE_H */
+
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/WebKit/android/stl/strings.h b/WebKit/android/stl/strings.h
new file mode 100644
index 0000000..13d6d4e
--- /dev/null
+++ b/WebKit/android/stl/strings.h
@@ -0,0 +1,17 @@
+/* 
+**
+** Copyright 2007, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+