Imported WebKit commit e2c32e2f53e02d388e70b9db88b91d8d9d28fc84 (http://svn.webkit.org/repository/webkit/trunk@133952)

Revert back to an older snapshot that should build on ARM

24 files changed, 96 insertions, 147 deletions

diff --git a/Source/WebCore/platform/blackberry/CookieManager.cpp b/Source/WebCore/platform/blackberry/CookieManager.cpp
index 1377658ad..f2554941b 100644
--- a/Source/WebCore/platform/blackberry/CookieManager.cpp
+++ b/Source/WebCore/platform/blackberry/CookieManager.cpp
@@ -118,10 +118,10 @@ static bool cookieSorter(ParsedCookie* a, ParsedCookie* b)
     return a->path().length() > b->path().length();
 }
 
-// Return whether we should ignore the scheme
-static bool shouldIgnoreScheme(const String& protocol)
+// Returns whether the protocol supports domains
+static bool shouldIgnoreDomain(const String protocol)
 {
-    // We want to ignore file and local schemes
+    // ignore domain security for file and local
     return protocol == "file" || protocol == "local";
 }
 
@@ -212,9 +212,8 @@ void CookieManager::getRawCookies(Vector<ParsedCookie*> &stackOfCookies, const K
 {
     CookieLog("CookieManager - getRawCookies - processing url with domain - %s & protocol: %s & path: %s\n", requestURL.host().utf8().data(), requestURL.protocol().utf8().data(), requestURL.path().utf8().data());
 
-    const bool invalidScheme = shouldIgnoreScheme(requestURL.protocol());
-    const bool specialCaseForWebWorks = invalidScheme && m_shouldDumpAllCookies;
-    const bool isConnectionSecure = requestURL.protocolIs("https") || requestURL.protocolIs("wss") || specialCaseForWebWorks;
+    bool specialCaseForLocal = (requestURL.protocolIs("local") || requestURL.protocolIs("file")) && m_shouldDumpAllCookies;
+    bool isConnectionSecure = requestURL.protocolIs("https") || requestURL.protocolIs("wss") || specialCaseForLocal;
 
     Vector<ParsedCookie*> cookieCandidates;
     Vector<CookieMap*> protocolsToSearch;
@@ -231,13 +230,8 @@ void CookieManager::getRawCookies(Vector<ParsedCookie*> &stackOfCookies, const K
             targetMap = m_managerMap.get("ws");
     }
 
-    // Decide which scheme tree we should look at.
-    // Return on invalid schemes. cookies are currently disabled on file and local.
-    // We only want to enable them for WebWorks that enabled a special flag.
-    if (specialCaseForWebWorks)
+    if (specialCaseForLocal)
         copyValuesToVector(m_managerMap, protocolsToSearch);
-    else if (invalidScheme)
-        return;
     else {
         protocolsToSearch.append(targetMap);
         // FIXME: this is a hack for webworks apps; RFC 6265 says "Cookies do not provide isolation by scheme"
@@ -270,7 +264,7 @@ void CookieManager::getRawCookies(Vector<ParsedCookie*> &stackOfCookies, const K
         CookieLog("CookieManager - looking at protocol map %s \n", currentMap->getName().utf8().data());
 
         // Special case for local and files - because WebApps expect to get ALL cookies from the backing-store on local protocol
-        if (specialCaseForWebWorks) {
+        if (specialCaseForLocal) {
             CookieLog("CookieManager - special case find in protocol map - %s\n", currentMap->getName().utf8().data());
             currentMap->getAllChildCookies(&cookieCandidates);
         } else {
@@ -306,7 +300,7 @@ void CookieManager::getRawCookies(Vector<ParsedCookie*> &stackOfCookies, const K
         if (!equalIgnoringCase(path, requestURL.path()) && !path.endsWith("/", false))
             path = path + "/";
 
-        // Only secure connections have access to secure cookies. Unless specialCaseForWebWorks is true.
+        // Only secure connections have access to secure cookies. Unless specialCaseForLocal is true
         // Get the cookies filtering out HttpOnly cookies if requested.
         if (requestURL.path().startsWith(path, false) && (isConnectionSecure || !cookie->isSecure()) && (filter == WithHttpOnlyCookies || !cookie->isHttpOnly())) {
             CookieLog("CookieManager - cookie chosen - %s\n", cookie->toString().utf8().data());
@@ -340,15 +334,13 @@ void CookieManager::checkAndTreatCookie(ParsedCookie* candidateCookie, BackingSt
 {
     CookieLog("CookieManager - checkAndTreatCookie - processing url with domain - %s & protocol %s\n", candidateCookie->domain().utf8().data(), candidateCookie->protocol().utf8().data());
 
-    // Delete invalid cookies:
-    // 1) A cookie which is not from http shouldn't have a httpOnly property.
-    // 2) Cookies coming from schemes that we do not support and the special flag isn't on
-    if ((filter == NoHttpOnlyCookie && candidateCookie->isHttpOnly()) || (shouldIgnoreScheme(candidateCookie->protocol()) && !m_shouldDumpAllCookies)) {
+    // A cookie which is not from http shouldn't have a httpOnly property.
+    if (filter == NoHttpOnlyCookie && candidateCookie->isHttpOnly()) {
         delete candidateCookie;
         return;
     }
 
-    const bool ignoreDomain = (candidateCookie->protocol() == "file" || candidateCookie->protocol() == "local");
+    const bool ignoreDomain = shouldIgnoreDomain(candidateCookie->protocol());
 
     // Determine which protocol tree to add the cookie to. Create one if necessary.
     CookieMap* curMap = 0;
diff --git a/Source/WebCore/platform/graphics/FontCache.cpp b/Source/WebCore/platform/graphics/FontCache.cpp
index a4ac7ea36..f60883ab3 100644
--- a/Source/WebCore/platform/graphics/FontCache.cpp
+++ b/Source/WebCore/platform/graphics/FontCache.cpp
@@ -134,8 +134,8 @@ static FontPlatformDataCache* gFontPlatformDataCache = 0;
 static const AtomicString& alternateFamilyName(const AtomicString& familyName)
 {
     // Alias Courier <-> Courier New
-    DEFINE_STATIC_LOCAL(AtomicString, courier, ("Courier", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(AtomicString, courierNew, ("Courier New", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, courier, ("Courier"));
+    DEFINE_STATIC_LOCAL(AtomicString, courierNew, ("Courier New"));
     if (equalIgnoringCase(familyName, courier))
         return courierNew;
 #if !OS(WINDOWS)
@@ -147,16 +147,16 @@ static const AtomicString& alternateFamilyName(const AtomicString& familyName)
 #endif
 
     // Alias Times and Times New Roman.
-    DEFINE_STATIC_LOCAL(AtomicString, times, ("Times", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(AtomicString, timesNewRoman, ("Times New Roman", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, times, ("Times"));
+    DEFINE_STATIC_LOCAL(AtomicString, timesNewRoman, ("Times New Roman"));
     if (equalIgnoringCase(familyName, times))
         return timesNewRoman;
     if (equalIgnoringCase(familyName, timesNewRoman))
         return times;
     
     // Alias Arial and Helvetica
-    DEFINE_STATIC_LOCAL(AtomicString, arial, ("Arial", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(AtomicString, helvetica, ("Helvetica", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, arial, ("Arial"));
+    DEFINE_STATIC_LOCAL(AtomicString, helvetica, ("Helvetica"));
     if (equalIgnoringCase(familyName, arial))
         return helvetica;
     if (equalIgnoringCase(familyName, helvetica))
@@ -165,14 +165,14 @@ static const AtomicString& alternateFamilyName(const AtomicString& familyName)
 #if OS(WINDOWS)
     // On Windows, bitmap fonts are blocked altogether so that we have to 
     // alias MS Sans Serif (bitmap font) -> Microsoft Sans Serif (truetype font)
-    DEFINE_STATIC_LOCAL(AtomicString, msSans, ("MS Sans Serif", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(AtomicString, microsoftSans, ("Microsoft Sans Serif", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, msSans, ("MS Sans Serif"));
+    DEFINE_STATIC_LOCAL(AtomicString, microsoftSans, ("Microsoft Sans Serif"));
     if (equalIgnoringCase(familyName, msSans))
         return microsoftSans;
 
     // Alias MS Serif (bitmap) -> Times New Roman (truetype font). There's no 
-    // 'Microsoft Sans Serif-equivalent' for Serif.
-    DEFINE_STATIC_LOCAL(AtomicString, msSerif, ("MS Serif", AtomicString::ConstructFromLiteral));
+    // 'Microsoft Sans Serif-equivalent' for Serif. 
+    static AtomicString msSerif("MS Serif");
     if (equalIgnoringCase(familyName, msSerif))
         return timesNewRoman;
 #endif
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.cpp b/Source/WebCore/platform/graphics/MediaPlayer.cpp
index da93570a0..377e8dc7a 100644
--- a/Source/WebCore/platform/graphics/MediaPlayer.cpp
+++ b/Source/WebCore/platform/graphics/MediaPlayer.cpp
@@ -239,19 +239,19 @@ static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSuppo
 
 static const AtomicString& applicationOctetStream()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream"));
     return applicationOctetStream;
 }
 
 static const AtomicString& textPlain()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain"));
     return textPlain;
 }
 
 static const AtomicString& codecs()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs"));
     return codecs;
 }
 
diff --git a/Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp b/Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp
index cdf6006d7..431e96545 100644
--- a/Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp
+++ b/Source/WebCore/platform/graphics/blackberry/MediaPlayerPrivateBlackBerry.cpp
@@ -402,7 +402,7 @@ bool MediaPlayerPrivate::hasAvailableVideoFrame() const
 
 bool MediaPlayerPrivate::hasSingleSecurityOrigin() const
 {
-    return true;
+    return false;
 }
 
 MediaPlayer::MovieLoadType MediaPlayerPrivate::movieLoadType() const
diff --git a/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp b/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp
index 863ca127e..e9424dfc5 100644
--- a/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp
+++ b/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.cpp
@@ -34,7 +34,6 @@ namespace WebCore {
 DeferredImageDecoder::DeferredImageDecoder(ImageDecoder* actualDecoder)
     : m_allDataReceived(false)
     , m_actualDecoder(adoptPtr(actualDecoder))
-    , m_orientation(DefaultImageOrientation)
 {
 }
 
@@ -73,7 +72,6 @@ ImageFrame* DeferredImageDecoder::frameBufferAtIndex(size_t index)
 
         m_size = m_actualDecoder->size();
         m_filenameExtension = m_actualDecoder->filenameExtension();
-        m_orientation = m_actualDecoder->orientation();
 
         SkBitmap lazyDecodedSkBitmap = ImageDecodingStore::instanceOnMainThread()->createLazyDecodedSkBitmap(m_actualDecoder.release());
         m_lazyDecodedFrame.setSkBitmap(lazyDecodedSkBitmap);
@@ -155,7 +153,8 @@ unsigned DeferredImageDecoder::frameBytesAtIndex(size_t index) const
 
 ImageOrientation DeferredImageDecoder::orientation() const
 {
-    return m_actualDecoder ? m_actualDecoder->orientation() : m_orientation;
+    // FIXME: Make this work with deferred decoding.
+    return m_actualDecoder ? m_actualDecoder->orientation() : DefaultImageOrientation;
 }
 
 } // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.h b/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.h
index 60d8cc108..d82aec872 100644
--- a/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.h
+++ b/Source/WebCore/platform/graphics/chromium/DeferredImageDecoder.h
@@ -67,7 +67,6 @@ private:
 
     String m_filenameExtension;
     IntSize m_size;
-    ImageOrientation m_orientation;
 
     ImageFrame m_lazyDecodedFrame;
 };
diff --git a/Source/WebCore/platform/graphics/chromium/FontCacheAndroid.cpp b/Source/WebCore/platform/graphics/chromium/FontCacheAndroid.cpp
index aa54dc101..eba224a83 100644
--- a/Source/WebCore/platform/graphics/chromium/FontCacheAndroid.cpp
+++ b/Source/WebCore/platform/graphics/chromium/FontCacheAndroid.cpp
@@ -122,9 +122,9 @@ PassRefPtr<SimpleFontData> FontCache::getSimilarFontPlatformData(const Font& fon
 
 PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescription& description, ShouldRetain shouldRetain)
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, serif, ("Serif", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, monospace, ("Monospace", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, sans, ("Sans", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, serif, ("Serif"));
+    DEFINE_STATIC_LOCAL(const AtomicString, monospace, ("Monospace"));
+    DEFINE_STATIC_LOCAL(const AtomicString, sans, ("Sans"));
 
     FontPlatformData* fontPlatformData = 0;
     switch (description.genericFamily()) {
diff --git a/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp b/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
index 4cc5622f0..283501c53 100644
--- a/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
+++ b/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
@@ -39,7 +39,7 @@ PassRefPtr<SourceAlpha> SourceAlpha::create(Filter* filter)
 
 const AtomicString& SourceAlpha::effectName()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, s_effectName, ("SourceAlpha", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, s_effectName, ("SourceAlpha"));
     return s_effectName;
 }
 
diff --git a/Source/WebCore/platform/graphics/filters/SourceGraphic.cpp b/Source/WebCore/platform/graphics/filters/SourceGraphic.cpp
index 197d802f5..75b11ddf7 100644
--- a/Source/WebCore/platform/graphics/filters/SourceGraphic.cpp
+++ b/Source/WebCore/platform/graphics/filters/SourceGraphic.cpp
@@ -38,7 +38,7 @@ PassRefPtr<SourceGraphic> SourceGraphic::create(Filter* filter)
 
 const AtomicString& SourceGraphic::effectName()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, s_effectName, ("SourceGraphic", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, s_effectName, ("SourceGraphic"));
     return s_effectName;
 }
 
diff --git a/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.cpp b/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.cpp
index 91c239c0c..b7d444f08 100644
--- a/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.cpp
+++ b/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.cpp
@@ -72,12 +72,11 @@ static inline float harfbuzzPositionToFloat(hb_position_t value)
     return static_cast<float>(value) / (1 << 16);
 }
 
-HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
+HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction)
     : m_fontData(fontData)
     , m_startIndex(startIndex)
     , m_numCharacters(numCharacters)
     , m_direction(direction)
-    , m_script(script)
 {
 }
 
@@ -231,9 +230,7 @@ bool HarfBuzzShaper::shape(GlyphBuffer* glyphBuffer)
         return false;
 
     m_totalWidth = 0;
-    // WebKit doesn't set direction when calulating widths. Leave the direction setting to
-    // HarfBuzz when we are calculating widths (except when directionalOverride() is set).
-    if (!shapeHarfBuzzRuns(glyphBuffer || m_run.directionalOverride()))
+    if (!shapeHarfBuzzRuns())
         return false;
     m_totalWidth = roundf(m_totalWidth);
 
@@ -304,8 +301,7 @@ bool HarfBuzzShaper::collectHarfBuzzRuns()
             currentCharacterPosition = iterator.characters();
         }
         unsigned numCharactersOfCurrentRun = iterator.currentCharacter() - startIndexOfCurrentRun;
-        hb_script_t script = hb_icu_script_to_script(currentScript);
-        m_harfbuzzRuns.append(HarfBuzzRun::create(currentFontData, startIndexOfCurrentRun, numCharactersOfCurrentRun, m_run.direction(), script));
+        m_harfbuzzRuns.append(HarfBuzzRun::create(currentFontData, startIndexOfCurrentRun, numCharactersOfCurrentRun, m_run.direction()));
         currentFontData = nextFontData;
         startIndexOfCurrentRun = iterator.currentCharacter();
     } while (iterator.consume(character, clusterLength));
@@ -313,21 +309,19 @@ bool HarfBuzzShaper::collectHarfBuzzRuns()
     return !m_harfbuzzRuns.isEmpty();
 }
 
-bool HarfBuzzShaper::shapeHarfBuzzRuns(bool shouldSetDirection)
+bool HarfBuzzShaper::shapeHarfBuzzRuns()
 {
     HarfBuzzScopedPtr<hb_buffer_t> harfbuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
 
     hb_buffer_set_unicode_funcs(harfbuzzBuffer.get(), hb_icu_get_unicode_funcs());
+    if (m_run.rtl() || m_run.directionalOverride())
+        hb_buffer_set_direction(harfbuzzBuffer.get(), m_run.rtl() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
 
     for (unsigned i = 0; i < m_harfbuzzRuns.size(); ++i) {
         unsigned runIndex = m_run.rtl() ? m_harfbuzzRuns.size() - i - 1 : i;
         HarfBuzzRun* currentRun = m_harfbuzzRuns[runIndex].get();
         const SimpleFontData* currentFontData = currentRun->fontData();
 
-        hb_buffer_set_script(harfbuzzBuffer.get(), currentRun->script());
-        if (shouldSetDirection)
-            hb_buffer_set_direction(harfbuzzBuffer.get(), currentRun->rtl() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
-
         // This #if should be removed after all ports update harfbuzz-ng.
 #if PLATFORM(CHROMIUM)
         // Add a space as pre-context to the buffer. This prevents showing dotted-circle
@@ -360,6 +354,8 @@ bool HarfBuzzShaper::shapeHarfBuzzRuns(bool shouldSetDirection)
         setGlyphPositionsForHarfBuzzRun(currentRun, harfbuzzBuffer.get());
 
         hb_buffer_reset(harfbuzzBuffer.get());
+        if (m_run.rtl() || m_run.directionalOverride())
+            hb_buffer_set_direction(harfbuzzBuffer.get(), m_run.rtl() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
     }
 
     return true;
diff --git a/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.h b/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.h
index 92ed1911d..c3c402ba4 100644
--- a/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.h
+++ b/Source/WebCore/platform/graphics/harfbuzz/ng/HarfBuzzShaper.h
@@ -61,9 +61,9 @@ public:
 private:
     class HarfBuzzRun {
     public:
-        static PassOwnPtr<HarfBuzzRun> create(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
+        static PassOwnPtr<HarfBuzzRun> create(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction)
         {
-            return adoptPtr(new HarfBuzzRun(fontData, startIndex, numCharacters, direction, script));
+            return adoptPtr(new HarfBuzzRun(fontData, startIndex, numCharacters, direction));
         }
 
         void applyShapeResult(hb_buffer_t*);
@@ -82,18 +82,16 @@ private:
         FloatPoint* offsets() { return &m_offsets[0]; }
         uint16_t* glyphToCharacterIndexes() { return &m_glyphToCharacterIndexes[0]; }
         float width() { return m_width; }
-        bool rtl() { return m_direction == RTL; }
-        hb_script_t script() { return m_script; }
 
     private:
-        HarfBuzzRun(const SimpleFontData*, unsigned startIndex, unsigned numCharacters, TextDirection, hb_script_t);
+        HarfBuzzRun(const SimpleFontData*, unsigned startIndex, unsigned numCharacters, TextDirection);
+        bool rtl() { return m_direction == RTL; }
 
         const SimpleFontData* m_fontData;
         unsigned m_startIndex;
         size_t m_numCharacters;
         unsigned m_numGlyphs;
         TextDirection m_direction;
-        hb_script_t m_script;
         Vector<uint16_t, 256> m_glyphs;
         Vector<float, 256> m_advances;
         Vector<uint16_t, 256> m_glyphToCharacterIndexes;
@@ -104,7 +102,7 @@ private:
     void setFontFeatures();
 
     bool collectHarfBuzzRuns();
-    bool shapeHarfBuzzRuns(bool shouldSetDirection);
+    bool shapeHarfBuzzRuns();
     bool fillGlyphBuffer(GlyphBuffer*);
     void fillGlyphBufferFromHarfBuzzRun(GlyphBuffer*, HarfBuzzRun*, FloatPoint& firstOffsetOfNextRun);
     void setGlyphPositionsForHarfBuzzRun(HarfBuzzRun*, hb_buffer_t*);
diff --git a/Source/WebCore/platform/graphics/mac/FontCacheMac.mm b/Source/WebCore/platform/graphics/mac/FontCacheMac.mm
index 3fa433f3d..d1dc8162a 100644
--- a/Source/WebCore/platform/graphics/mac/FontCacheMac.mm
+++ b/Source/WebCore/platform/graphics/mac/FontCacheMac.mm
@@ -182,7 +182,7 @@ PassRefPtr<SimpleFontData> FontCache::getSimilarFontPlatformData(const Font& fon
     while (currFamily && !simpleFontData) {
         if (currFamily->family().length()) {
             static String* matchWords[3] = { new String("Arabic"), new String("Pashto"), new String("Urdu") };
-            DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro", AtomicString::ConstructFromLiteral));
+            DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro"));
             for (int j = 0; j < 3 && !simpleFontData; ++j)
                 if (currFamily->family().contains(*matchWords[j], false))
                     simpleFontData = getCachedFontData(font.fontDescription(), geezaStr);
@@ -195,7 +195,7 @@ PassRefPtr<SimpleFontData> FontCache::getSimilarFontPlatformData(const Font& fon
 
 PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescription& fontDescription, ShouldRetain shouldRetain)
 {
-    DEFINE_STATIC_LOCAL(AtomicString, timesStr, ("Times", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, timesStr, ("Times"));
 
     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
     // the default that the user would get without changing any prefs.
@@ -207,7 +207,7 @@ PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescri
     // the user doesn't have it, we fall back on Lucida Grande because that's
     // guaranteed to be there, according to Nathan Taylor. This is good enough
     // to avoid a crash at least.
-    DEFINE_STATIC_LOCAL(AtomicString, lucidaGrandeStr, ("Lucida Grande", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, lucidaGrandeStr, ("Lucida Grande"));
     return getCachedFontData(fontDescription, lucidaGrandeStr, false, shouldRetain);
 }
 
diff --git a/Source/WebCore/platform/graphics/skia/FontCacheSkia.cpp b/Source/WebCore/platform/graphics/skia/FontCacheSkia.cpp
index e59efa5d9..336abc430 100644
--- a/Source/WebCore/platform/graphics/skia/FontCacheSkia.cpp
+++ b/Source/WebCore/platform/graphics/skia/FontCacheSkia.cpp
@@ -95,9 +95,9 @@ PassRefPtr<SimpleFontData> FontCache::getSimilarFontPlatformData(const Font& fon
 
 PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescription& description, ShouldRetain shouldRetain)
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, sansStr, ("Sans", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, serifStr, ("Serif", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, monospaceStr, ("Monospace", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, sansStr, ("Sans"));
+    DEFINE_STATIC_LOCAL(const AtomicString, serifStr, ("Serif"));
+    DEFINE_STATIC_LOCAL(const AtomicString, monospaceStr, ("Monospace"));
 
     FontPlatformData* fontPlatformData = 0;
     switch (description.genericFamily()) {
@@ -115,7 +115,7 @@ PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescri
 
     if (!fontPlatformData) {
         // we should at least have Arial; this is the SkFontHost_fontconfig last resort fallback
-        DEFINE_STATIC_LOCAL(const AtomicString, arialStr, ("Arial", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, arialStr, ("Arial"));
         fontPlatformData = getCachedFontPlatformData(description, arialStr);
     }
 
diff --git a/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h b/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h
index 6ca6d286d..510b23f5c 100644
--- a/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h
+++ b/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h
@@ -72,7 +72,7 @@ public:
     virtual void flushCompositingState(const FloatRect&);
     virtual void flushCompositingStateForThisLayerOnly();
     virtual void setName(const String& name);
-    virtual PlatformLayer* platformLayer() const { return m_contentsLayer; }
+    virtual PlatformLayer* platformLayer() const { return 0; }
 
     void notifyChange(TextureMapperLayer::ChangeMask);
     inline int changeMask() const { return m_changeMask; }
@@ -84,6 +84,7 @@ public:
     void setAnimations(const GraphicsLayerAnimations&);
 
     TextureMapperLayer* layer() const { return m_layer.get(); }
+    TextureMapperPlatformLayer* contentsLayer() const { return m_contentsLayer; }
     bool needsDisplay() const { return m_needsDisplay; }
     IntRect needsDisplayRect() const { return enclosingIntRect(m_needsDisplayRect); }
 
diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp
index fe6b6c0e1..401af8c3e 100644
--- a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp
+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp
@@ -169,15 +169,11 @@ void TextureMapperLayer::paintSelf(const TextureMapperPaintOptions& options)
     float opacity = options.opacity;
     RefPtr<BitmapTexture> mask = options.mask;
 
-    if (m_backingStore) {
-        ASSERT(!layerRect().isEmpty());
+    if (m_backingStore)
         m_backingStore->paintToTextureMapper(options.textureMapper, layerRect(), transform, opacity, mask.get());
-    }
 
-    if (m_contentsLayer) {
-        ASSERT(!layerRect().isEmpty());
+    if (m_contentsLayer)
         m_contentsLayer->paintToTextureMapper(options.textureMapper, m_state.contentsRect, transform, opacity, mask.get());
-    }
 }
 
 int TextureMapperLayer::compareGraphicsLayersZValue(const void* a, const void* b)
@@ -492,7 +488,7 @@ void TextureMapperLayer::flushCompositingStateSelf(GraphicsLayerTextureMapper* g
     m_state.needsDisplay = m_state.needsDisplay || graphicsLayer->needsDisplay();
     if (!m_state.needsDisplay)
         m_state.needsDisplayRect.unite(graphicsLayer->needsDisplayRect());
-    m_contentsLayer = graphicsLayer->platformLayer();
+    m_contentsLayer = graphicsLayer->contentsLayer();
 
     m_transform.setPosition(adjustedPosition());
     m_transform.setAnchorPoint(m_state.anchorPoint);
diff --git a/Source/WebCore/platform/graphics/win/FontCacheWin.cpp b/Source/WebCore/platform/graphics/win/FontCacheWin.cpp
index 2bec62a4d..2540fae97 100644
--- a/Source/WebCore/platform/graphics/win/FontCacheWin.cpp
+++ b/Source/WebCore/platform/graphics/win/FontCacheWin.cpp
@@ -323,11 +323,11 @@ PassRefPtr<SimpleFontData> FontCache::getLastResortFallbackFont(const FontDescri
     // Sorted by most to least glyphs according to http://en.wikipedia.org/wiki/Unicode_typefaces
     // Start with Times New Roman also since it is the default if the user doesn't change prefs.
     static AtomicString fallbackFonts[] = {
-        AtomicString("Times New Roman", AtomicString::ConstructFromLiteral),
-        AtomicString("Microsoft Sans Serif", AtomicString::ConstructFromLiteral),
-        AtomicString("Tahoma", AtomicString::ConstructFromLiteral),
-        AtomicString("Lucida Sans Unicode", AtomicString::ConstructFromLiteral),
-        AtomicString("Arial", AtomicString::ConstructFromLiteral)
+        AtomicString("Times New Roman"),
+        AtomicString("Microsoft Sans Serif"),
+        AtomicString("Tahoma"),
+        AtomicString("Lucida Sans Unicode"),
+        AtomicString("Arial")
     };
     RefPtr<SimpleFontData> simpleFont;
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(fallbackFonts); ++i) {
diff --git a/Source/WebCore/platform/graphics/wx/FontCacheWx.cpp b/Source/WebCore/platform/graphics/wx/FontCacheWx.cpp
index 5e90e059a..acd1dc3e1 100644
--- a/Source/WebCore/platform/graphics/wx/FontCacheWx.cpp
+++ b/Source/WebCore/platform/graphics/wx/FontCacheWx.cpp
@@ -67,7 +67,7 @@ PassRefPtr<SimpleFontData> FontCache::getSimilarFontPlatformData(const Font& fon
     while (currFamily && !simpleFontData) {
         if (currFamily->family().length()) {
             static String* matchWords[3] = { new String("Arabic"), new String("Pashto"), new String("Urdu") };
-            DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro", AtomicString::ConstructFromLiteral));
+            DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro"));
             for (int j = 0; j < 3 && !simpleFontData; ++j)
                 if (currFamily->family().contains(*matchWords[j], false))
                     simpleFontData = getCachedFontData(font.fontDescription(), geezaStr);
diff --git a/Source/WebCore/platform/leveldb/LevelDBDatabase.cpp b/Source/WebCore/platform/leveldb/LevelDBDatabase.cpp
index edf9db257..273afd4de 100644
--- a/Source/WebCore/platform/leveldb/LevelDBDatabase.cpp
+++ b/Source/WebCore/platform/leveldb/LevelDBDatabase.cpp
@@ -89,17 +89,6 @@ private:
     const LevelDBComparator* m_comparator;
 };
 
-LevelDBSnapshot::LevelDBSnapshot(LevelDBDatabase* db)
-    : m_db(db->m_db.get())
-    , m_snapshot(m_db->GetSnapshot())
-{
-}
-
-LevelDBSnapshot::~LevelDBSnapshot()
-{
-    m_db->ReleaseSnapshot(m_snapshot);
-}
-
 LevelDBDatabase::LevelDBDatabase()
 {
 }
@@ -198,12 +187,11 @@ bool LevelDBDatabase::remove(const LevelDBSlice& key)
     return false;
 }
 
-bool LevelDBDatabase::get(const LevelDBSlice& key, Vector<char>& value, const LevelDBSnapshot* snapshot)
+bool LevelDBDatabase::get(const LevelDBSlice& key, Vector<char>& value)
 {
     std::string result;
     leveldb::ReadOptions readOptions;
     readOptions.verify_checksums = true; // FIXME: Disable this if the performance impact is too great.
-    readOptions.snapshot = snapshot ? snapshot->m_snapshot : 0;
 
     const leveldb::Status s = m_db->Get(readOptions, makeSlice(key), &result);
     if (s.ok()) {
@@ -305,11 +293,10 @@ LevelDBSlice IteratorImpl::value() const
     return makeLevelDBSlice(m_iterator->value());
 }
 
-PassOwnPtr<LevelDBIterator> LevelDBDatabase::createIterator(const LevelDBSnapshot* snapshot)
+PassOwnPtr<LevelDBIterator> LevelDBDatabase::createIterator()
 {
     leveldb::ReadOptions readOptions;
     readOptions.verify_checksums = true; // FIXME: Disable this if the performance impact is too great.
-    readOptions.snapshot = snapshot ? snapshot->m_snapshot : 0;
     OwnPtr<leveldb::Iterator> i = adoptPtr(m_db->NewIterator(readOptions));
     if (!i) // FIXME: Double check if we actually need to check this.
         return nullptr;
diff --git a/Source/WebCore/platform/leveldb/LevelDBDatabase.h b/Source/WebCore/platform/leveldb/LevelDBDatabase.h
index 2d32cd736..e80b49a24 100644
--- a/Source/WebCore/platform/leveldb/LevelDBDatabase.h
+++ b/Source/WebCore/platform/leveldb/LevelDBDatabase.h
@@ -37,29 +37,15 @@ namespace leveldb {
 class Comparator;
 class DB;
 class Env;
-class Snapshot;
 }
 
 namespace WebCore {
 
 class LevelDBComparator;
-class LevelDBDatabase;
 class LevelDBIterator;
 class LevelDBSlice;
 class LevelDBWriteBatch;
 
-class LevelDBSnapshot {
-private:
-    friend class LevelDBDatabase;
-    friend class LevelDBTransaction;
-
-    explicit LevelDBSnapshot(LevelDBDatabase*);
-    ~LevelDBSnapshot();
-
-    leveldb::DB* m_db;
-    const leveldb::Snapshot* m_snapshot;
-};
-
 class LevelDBDatabase {
 public:
     static PassOwnPtr<LevelDBDatabase> open(const String& fileName, const LevelDBComparator*);
@@ -69,13 +55,12 @@ public:
 
     bool put(const LevelDBSlice& key, const Vector<char>& value);
     bool remove(const LevelDBSlice& key);
-    bool get(const LevelDBSlice& key, Vector<char>& value, const LevelDBSnapshot* = 0);
+    bool get(const LevelDBSlice& key, Vector<char>& value);
     bool write(LevelDBWriteBatch&);
-    PassOwnPtr<LevelDBIterator> createIterator(const LevelDBSnapshot* = 0);
+    PassOwnPtr<LevelDBIterator> createIterator();
     const LevelDBComparator* comparator() const;
 
 private:
-    friend class LevelDBSnapshot;
     LevelDBDatabase();
 
     OwnPtr<leveldb::Env> m_env;
diff --git a/Source/WebCore/platform/leveldb/LevelDBTransaction.cpp b/Source/WebCore/platform/leveldb/LevelDBTransaction.cpp
index fe8262a24..bf5ccbb7f 100644
--- a/Source/WebCore/platform/leveldb/LevelDBTransaction.cpp
+++ b/Source/WebCore/platform/leveldb/LevelDBTransaction.cpp
@@ -26,13 +26,12 @@
 #include "config.h"
 #include "LevelDBTransaction.h"
 
-#if ENABLE(INDEXED_DATABASE)
-#if USE(LEVELDB)
-
 #include "LevelDBDatabase.h"
 #include "LevelDBSlice.h"
 #include "LevelDBWriteBatch.h"
-#include <leveldb/db.h>
+
+#if ENABLE(INDEXED_DATABASE)
+#if USE(LEVELDB)
 
 namespace WebCore {
 
@@ -43,7 +42,6 @@ PassRefPtr<LevelDBTransaction> LevelDBTransaction::create(LevelDBDatabase* db)
 
 LevelDBTransaction::LevelDBTransaction(LevelDBDatabase* db)
     : m_db(db)
-    , m_snapshot(db)
     , m_comparator(db->comparator())
     , m_finished(false)
 {
@@ -120,7 +118,7 @@ bool LevelDBTransaction::get(const LevelDBSlice& key, Vector<char>& value)
         return true;
     }
 
-    return m_db->get(key, value, &m_snapshot);
+    return m_db->get(key, value);
 }
 
 bool LevelDBTransaction::commit()
@@ -259,7 +257,7 @@ LevelDBTransaction::TransactionIterator::TransactionIterator(PassRefPtr<LevelDBT
     : m_transaction(transaction)
     , m_comparator(m_transaction->m_comparator)
     , m_treeIterator(TreeIterator::create(m_transaction.get()))
-    , m_dbIterator(m_transaction->m_db->createIterator(&m_transaction->m_snapshot))
+    , m_dbIterator(m_transaction->m_db->createIterator())
     , m_current(0)
     , m_direction(kForward)
     , m_treeChanged(false)
diff --git a/Source/WebCore/platform/leveldb/LevelDBTransaction.h b/Source/WebCore/platform/leveldb/LevelDBTransaction.h
index 94236ff76..85b734ff0 100644
--- a/Source/WebCore/platform/leveldb/LevelDBTransaction.h
+++ b/Source/WebCore/platform/leveldb/LevelDBTransaction.h
@@ -30,7 +30,6 @@
 #if USE(LEVELDB)
 
 #include "LevelDBComparator.h"
-#include "LevelDBDatabase.h"
 #include "LevelDBIterator.h"
 #include "LevelDBSlice.h"
 #include <wtf/AVLTree.h>
@@ -43,6 +42,7 @@
 
 namespace WebCore {
 
+class LevelDBDatabase;
 class LevelDBWriteBatch;
 
 using WTF::AVLTree;
@@ -164,7 +164,6 @@ private:
     void notifyIteratorsOfTreeChange();
 
     LevelDBDatabase* m_db;
-    const LevelDBSnapshot m_snapshot;
     const LevelDBComparator* m_comparator;
     TreeType m_tree;
     bool m_finished;
diff --git a/Source/WebCore/platform/network/ResourceResponseBase.cpp b/Source/WebCore/platform/network/ResourceResponseBase.cpp
index 5902e7961..48568ef6f 100644
--- a/Source/WebCore/platform/network/ResourceResponseBase.cpp
+++ b/Source/WebCore/platform/network/ResourceResponseBase.cpp
@@ -280,12 +280,12 @@ void ResourceResponseBase::setHTTPHeaderField(const AtomicString& name, const St
 {
     lazyInit(CommonAndUncommonFields);
 
-    DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age"));
+    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control"));
+    DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date"));
+    DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires"));
+    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified"));
+    DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
     if (equalIgnoringCase(name, ageHeader))
         m_haveParsedAgeHeader = false;
     else if (equalIgnoringCase(name, cacheControlHeader) || equalIgnoringCase(name, pragmaHeader))
@@ -319,11 +319,11 @@ void ResourceResponseBase::parseCacheControlDirectives() const
     m_cacheControlContainsNoCache = false;
     m_cacheControlMaxAge = numeric_limits<double>::quiet_NaN();
 
-    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control"));
+    DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache"));
+    DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store"));
+    DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate"));
+    DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age"));
 
     String cacheControlValue = m_httpHeaderFields.get(cacheControlString);
     if (!cacheControlValue.isEmpty()) {
@@ -357,7 +357,7 @@ void ResourceResponseBase::parseCacheControlDirectives() const
         // Handle Pragma: no-cache
         // This is deprecated and equivalent to Cache-control: no-cache
         // Don't bother tokenizing the value, it is not important
-        DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
         String pragmaValue = m_httpHeaderFields.get(pragmaHeader);
 
         m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective);
@@ -389,8 +389,8 @@ bool ResourceResponseBase::hasCacheValidatorFields() const
 {
     lazyInit(CommonFieldsOnly);
 
-    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified", AtomicString::ConstructFromLiteral));
-    DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified"));
+    DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag"));
     return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() || !m_httpHeaderFields.get(eTagHeader).isEmpty();
 }
 
@@ -421,7 +421,7 @@ double ResourceResponseBase::date() const
     lazyInit(CommonFieldsOnly);
 
     if (!m_haveParsedDateHeader) {
-        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date"));
         m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
         m_haveParsedDateHeader = true;
     }
@@ -433,7 +433,7 @@ double ResourceResponseBase::age() const
     lazyInit(CommonFieldsOnly);
 
     if (!m_haveParsedAgeHeader) {
-        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age"));
         String headerValue = m_httpHeaderFields.get(headerName);
         bool ok;
         m_age = headerValue.toDouble(&ok);
@@ -449,7 +449,7 @@ double ResourceResponseBase::expires() const
     lazyInit(CommonFieldsOnly);
 
     if (!m_haveParsedExpiresHeader) {
-        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires"));
         m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
         m_haveParsedExpiresHeader = true;
     }
@@ -461,7 +461,7 @@ double ResourceResponseBase::lastModified() const
     lazyInit(CommonFieldsOnly);
 
     if (!m_haveParsedLastModifiedHeader) {
-        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified", AtomicString::ConstructFromLiteral));
+        DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified"));
         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
         m_haveParsedLastModifiedHeader = true;
     }
@@ -472,13 +472,13 @@ bool ResourceResponseBase::isAttachment() const
 {
     lazyInit(CommonAndUncommonFields);
 
-    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition"));
     String value = m_httpHeaderFields.get(headerName);
     size_t loc = value.find(';');
     if (loc != notFound)
         value = value.left(loc);
     value = value.stripWhiteSpace();
-    DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment"));
     return equalIgnoringCase(value, attachmentString);
 }
   
diff --git a/Source/WebCore/platform/text/enchant/TextCheckerEnchant.cpp b/Source/WebCore/platform/text/enchant/TextCheckerEnchant.cpp
index f9b30df6a..28633f15f 100644
--- a/Source/WebCore/platform/text/enchant/TextCheckerEnchant.cpp
+++ b/Source/WebCore/platform/text/enchant/TextCheckerEnchant.cpp
@@ -72,7 +72,7 @@ void TextCheckerEnchant::checkSpellingOfString(const String& string, int& misspe
     misspellingLocation = -1;
     misspellingLength = 0;
 
-    if (!hasDictionary())
+    if (m_enchantDictionaries.isEmpty())
         return;
 
     size_t numberOfCharacters = string.length();
@@ -121,7 +121,7 @@ void TextCheckerEnchant::checkSpellingOfString(const String& string, int& misspe
 Vector<String> TextCheckerEnchant::getGuessesForWord(const String& word)
 {
     Vector<String> guesses;
-    if (!hasDictionary())
+    if (m_enchantDictionaries.isEmpty())
         return guesses;
 
     for (Vector<EnchantDict*>::const_iterator iter = m_enchantDictionaries.begin(); iter != m_enchantDictionaries.end(); ++iter) {
@@ -180,7 +180,7 @@ void TextCheckerEnchant::updateSpellCheckingLanguages(const Vector<String>& lang
 Vector<String> TextCheckerEnchant::loadedSpellCheckingLanguages() const
 {
     Vector<String> languages;
-    if (!hasDictionary())
+    if (m_enchantDictionaries.isEmpty())
         return languages;
 
     // Get a Vector<CString> with the list of languages in use.
diff --git a/Source/WebCore/platform/text/enchant/TextCheckerEnchant.h b/Source/WebCore/platform/text/enchant/TextCheckerEnchant.h
index 0fe2caaa9..787f8bf5a 100644
--- a/Source/WebCore/platform/text/enchant/TextCheckerEnchant.h
+++ b/Source/WebCore/platform/text/enchant/TextCheckerEnchant.h
@@ -43,7 +43,6 @@ public:
     Vector<String> getGuessesForWord(const String&);
     void updateSpellCheckingLanguages(const Vector<String>& languages);
     Vector<String> loadedSpellCheckingLanguages() const;
-    bool hasDictionary() const { return !m_enchantDictionaries.isEmpty(); }
     Vector<String> availableSpellCheckingLanguages() const;
 
 private: