Remove OS(WINCE) as blink and chromium does not support WinCe.

Source/wtf/StackBounds.cpp

 /*
  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
@@ skipping 42 matching lines @@
 
 #endif
 
 namespace WTF {
 
 // Bug 26276 - Need a mechanism to determine stack extent
 //
 // These platforms should now be working correctly:
 //     DARWIN, QNX, UNIX
 // These platforms are not:
-//     WINDOWS, SOLARIS, OPENBSD, WINCE
+//     WINDOWS, SOLARIS, OPENBSD
 //
 // FIXME: remove this! - this code unsafely guesses at stack sizes!
 #if OS(WINDOWS) || OS(SOLARIS) || OS(OPENBSD)
 // Based on the current limit used by the JSC parser, guess the stack size.
 static const ptrdiff_t estimatedStackSize = 128 * sizeof(void*) * 1024;
 // This method assumes the stack is growing downwards.
 static void* estimateStackBound(void* origin)
 {
     return static_cast<char*>(origin) - estimatedStackSize;
 }
@@ skipping 72 matching lines @@
     pthread_getattr_np(thread, &sattr);
 #endif
     int rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);
     (void)rc; // FIXME: Deal with error code somehow? Seems fatal.
     ASSERT(stackBase);
     pthread_attr_destroy(&sattr);
     m_bound = stackBase;
     m_origin = static_cast<char*>(stackBase) + stackSize;
 }
 
-#elif OS(WINCE)
-
-static bool detectGrowingDownward(void* previousFrame)
-{
-    // Find the address of this stack frame by taking the address of a local variable.
-    int thisFrame;
-    return previousFrame > &thisFrame;
-}
-
-static inline bool isPageWritable(void* page)
-{
-    MEMORY_BASIC_INFORMATION memoryInformation;
-    DWORD result = VirtualQuery(page, &memoryInformation, sizeof(memoryInformation));
-
-    // return false on error, including ptr outside memory
-    if (result != sizeof(memoryInformation))
-        return false;
-
-    DWORD protect = memoryInformation.Protect & ~(PAGE_GUARD | PAGE_NOCACHE);
-    return protect == PAGE_READWRITE
-        || protect == PAGE_WRITECOPY
-        || protect == PAGE_EXECUTE_READWRITE
-        || protect == PAGE_EXECUTE_WRITECOPY;
-}
-
-static inline void* getLowerStackBound(char* currentPage, DWORD pageSize)
-{
-    while (currentPage > 0) {
-        // check for underflow
-        if (currentPage >= reinterpret_cast<char*>(pageSize))
-            currentPage -= pageSize;
-        else
-            currentPage = 0;
-
-        if (!isPageWritable(currentPage))
-            return currentPage + pageSize;
-    }
-
-    return 0;
-}
-
-static inline void* getUpperStackBound(char* currentPage, DWORD pageSize)
-{
-    do {
-        // guaranteed to complete because isPageWritable returns false at end of memory
-        currentPage += pageSize;
-    } while (isPageWritable(currentPage));
-
-    return currentPage - pageSize;
-}
-
-void StackBounds::initialize()
-{
-    // find the address of this stack frame by taking the address of a local variable
-    void* thisFrame = &thisFrame;
-    bool isGrowingDownward = detectGrowingDownward(thisFrame);
-
-    SYSTEM_INFO systemInfo;
-    GetSystemInfo(&systemInfo);
-    DWORD pageSize = systemInfo.dwPageSize;
-
-    // scan all of memory starting from this frame, and return the last writeable page found
-    char* currentPage = reinterpret_cast<char*>(reinterpret_cast<DWORD>(thisFrame) & ~(pageSize - 1));
-    void* lowerStackBound = getLowerStackBound(currentPage, pageSize);
-    void* upperStackBound = getUpperStackBound(currentPage, pageSize);
-
-    m_origin = isGrowingDownward ? upperStackBound : lowerStackBound;
-    m_bound = isGrowingDownward ? lowerStackBound : upperStackBound;
-}
-
 #elif OS(WINDOWS)
 
 void StackBounds::initialize()
 {
 #if CPU(X86) && COMPILER(MSVC)
     // offset 0x18 from the FS segment register gives a pointer to
     // the thread information block for the current thread
     NT_TIB* pTib;
     __asm {
         MOV EAX, FS:[18h]
@@ skipping 16 matching lines @@
 #endif
     // Looks like we should be able to get pTib->StackLimit
     m_bound = estimateStackBound(m_origin);
 }
 
 #else
 #error Need a way to get the stack bounds on this platform
 #endif
 
 } // namespace WTF