Move ownership of the TextResourceDecoder to DecodedDataDocumentParser

Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 113 matching lines @@
 #include "core/html/parser/NestingLevelIncrementer.h"
 #include "core/inspector/InspectorCounters.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/CookieJar.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/ImageLoader.h"
 #include "core/loader/Prerenderer.h"
-#include "core/loader/TextResourceDecoder.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/ContentSecurityPolicy.h"
 #include "core/page/DOMSecurityPolicy.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameTree.h"
 #include "core/page/FrameView.h"
@@ skipping 385 matching lines @@
     // generally keep at least one reference to an Element which would in turn
     // has a reference to the Document.  If you hit this ASSERT, then that
     // assumption is wrong.  DocumentParser::detach() should ensure that even
     // if the DocumentParser outlives the Document it won't cause badness.
     ASSERT(!m_parser || m_parser->refCount() == 1);
     detachParser();
 
     if (this == topDocument())
         clearAXObjectCache();
 
-    setDecoder(PassRefPtr<TextResourceDecoder>());
-
     if (m_styleSheetList)
         m_styleSheetList->detachFromDocument();
 
     if (m_import) {
         m_import->wasDetachedFromDocument();
         m_import = 0;
     }
 
     m_styleSheetCollections.clear();
 
@@ skipping 556 matching lines @@
 
     m_readyState = readyState;
     dispatchEvent(Event::create(eventNames().readystatechangeEvent));
 }
 
 String Document::encodingName() const
 {
     // TextEncoding::domName() returns a char*, no need to allocate a new
     // String for it each time.
     // FIXME: We should fix TextEncoding to speak AtomicString anyway.
-    return AtomicString(m_encoding.domName());
+    return AtomicString(encoding().domName());
 }
 
 String Document::defaultCharset() const
 {
     if (Settings* settings = this->settings())
         return settings->defaultTextEncodingName();
     return String();
 }
 
 void Document::setCharset(const String& charset)
 {
-    if (!decoder())
+    if (DocumentLoader* documentLoader = loader())
+        documentLoader->setUserChosenEncoding(charset);
+    WTF::TextEncoding encoding(charset);
+    // In case the encoding didn't exist, we keep the old one (helps some sites specifying invalid encodings).
+    if (!encoding.isValid())
         return;
-    decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
-    setEncoding(m_decoder->encoding());
+    DocumentEncodingData data;
+    data.encoding = encoding;
+    setEncoding(data);

[abarth-chromium, 2013/08/30 22:50:38]

Won't this get spammed over the next time we get a chunk of data from the
network?

 }
 
 void Document::setContentLanguage(const String& language)
 {
     if (m_contentLanguage == language)
         return;
     m_contentLanguage = language;
 
     // Document's style depends on the content language.
     setNeedsStyleRecalc();
@@ skipping 2785 matching lines @@
     if (!length) {
         es.throwDOMException(InvalidCharacterError);
         return false;
     }
 
     if (qualifiedName.is8Bit())
         return parseQualifiedNameInternal(qualifiedName, qualifiedName.characters8(), length, prefix, localName, es);
     return parseQualifiedNameInternal(qualifiedName, qualifiedName.characters16(), length, prefix, localName, es);
 }
 
-void Document::setDecoder(PassRefPtr<TextResourceDecoder> decoder)
+Document::DocumentEncodingData::DocumentEncodingData()
+    : wasDetectedHeuristically(false)
+    , sawDecodingError(false)
 {
-    m_decoder = decoder;
-    setEncoding(m_decoder ? m_decoder->encoding() : WTF::TextEncoding());
 }
 
-void Document::setEncoding(const WTF::TextEncoding& encoding)
+void Document::setEncoding(DocumentEncodingData data)
 {
-    m_encoding = encoding;
+    m_encodingData = data;
 }
 
 KURL Document::completeURL(const String& url, const KURL& baseURLOverride) const
 {
     // Always return a null URL when passed a null string.
     // FIXME: Should we change the KURL constructor to have this behavior?
     // See also [CSS]StyleSheet::completeURL(const String&)
     if (url.isNull())
         return KURL();
     const KURL& baseURL = ((baseURLOverride.isEmpty() || baseURLOverride == blankURL()) && parentDocument()) ? parentDocument()->baseURL() : baseURLOverride;
-    if (!m_decoder)
+    if (!encoding().isValid())
         return KURL(baseURL, url);
-    return KURL(baseURL, url, m_decoder->encoding());
+    return KURL(baseURL, url, encoding());
 }
 
 KURL Document::completeURL(const String& url) const
 {
     return completeURL(url, m_baseURL);
 }
 
 void Document::documentWillBecomeInactive()
 {
     if (renderer())
@@ skipping 699 matching lines @@
 }
 
 void Document::resumeScriptedAnimationControllerCallbacks()
 {
     if (m_scriptedAnimationController)
         m_scriptedAnimationController->resume();
 }
 
 String Document::displayStringModifiedByEncoding(const String& str) const
 {
-    if (m_decoder)
-        return m_decoder->encoding().displayString(str.impl());
+    if (encoding().isValid())
+        return encoding().displayString(str.impl());
     return str;
 }
 
 PassRefPtr<StringImpl> Document::displayStringModifiedByEncoding(PassRefPtr<StringImpl> str) const
 {
-    if (m_decoder)
-        return m_decoder->encoding().displayString(str);
+    if (encoding().isValid())
+        return encoding().displayString(str);
     return str;
 }
 
 template <typename CharacterType>
 void Document::displayBufferModifiedByEncodingInternal(CharacterType* buffer, unsigned len) const
 {
-    if (m_decoder)
-        m_decoder->encoding().displayBuffer(buffer, len);
+    if (encoding().isValid())
+        encoding().displayBuffer(buffer, len);
 }
 
 // Generate definitions for both character types
 template void Document::displayBufferModifiedByEncodingInternal<LChar>(LChar*, unsigned) const;
 template void Document::displayBufferModifiedByEncodingInternal<UChar>(UChar*, unsigned) const;
 
 void Document::enqueuePageshowEvent(PageshowEventPersistence persisted)
 {
     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36334 Pageshow event needs to fire asynchronously.
     dispatchWindowEvent(PageTransitionEvent::create(eventNames().pageshowEvent, persisted), this);
@@ skipping 547 matching lines @@
 {
     return DocumentLifecycleNotifier::create(this);
 }
 
 DocumentLifecycleNotifier* Document::lifecycleNotifier()
 {
     return static_cast<DocumentLifecycleNotifier*>(ScriptExecutionContext::lifecycleNotifier());
 }
 
 } // namespace WebCore