japanese encoding webkit fixes for 3.0 branch

third_party/WebKit/WebCore/loader/TextResourceDecoder.cpp

 /*
     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
     Copyright (C) 2005, 2006, 2007 Alexey Proskuryakov (ap@nypop.com)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
@@ skipping 74 matching lines @@
 }
 
 static TextEncoding findTextEncoding(const char* encodingName, int length)
 {
     Vector<char, 64> buffer(length + 1);
     memcpy(buffer.data(), encodingName, length);
     buffer[length] = '\0';
     return buffer.data();
 }
 
+#if !PLATFORM(CHROMIUM)
 class KanjiCode {
 public:
     enum Type { ASCII, JIS, EUC, SJIS, UTF16, UTF8 };
     static enum Type judge(const char* str, int length);
     static const int ESC = 0x1b;
     static const unsigned char sjisMap[256];
     static int ISkanji(int code)
     {
         if (code >= 0x100)
             return 0;
@@ skipping 188 matching lines @@
     if (code == ASCII) {
         if (sjis > euc) {
             code = SJIS;
         } else if (sjis < euc) {
             code = EUC;
         }
     }
 breakBreak:
     return (code);
 }
+#endif
 
 TextResourceDecoder::ContentType TextResourceDecoder::determineContentType(const String& mimeType)
 {
     if (equalIgnoringCase(mimeType, "text/css"))
         return CSS;
     if (equalIgnoringCase(mimeType, "text/html"))
         return HTML;
     if (DOMImplementation::isXMLMIMEType(mimeType))
         return XML;
     return PlainText;
@@ skipping 426 matching lines @@
                     m_checkedForHeadCharset = true;
                     return true;
                 }
             }
         } else
             ++ptr;
     }
     return false;
 }
 
+#if !PLATFORM(CHROMIUM)
 void TextResourceDecoder::detectJapaneseEncoding(const char* data, size_t len)
 {
     switch (KanjiCode::judge(data, len)) {
         case KanjiCode::JIS:
             setEncoding("ISO-2022-JP", AutoDetectedEncoding);
             break;
         case KanjiCode::EUC:
             setEncoding("EUC-JP", AutoDetectedEncoding);
             break;
         case KanjiCode::SJIS:
             setEncoding("Shift_JIS", AutoDetectedEncoding);
             break;
         case KanjiCode::ASCII:
         case KanjiCode::UTF16:
         case KanjiCode::UTF8:
             break;
     }
 }
+#endif
 
 // We use the encoding detector in two cases:
 //   1. Encoding detector is turned ON and no other encoding source is
 //      available (that is, it's DefaultEncoding).
 //   2. Encoding detector is turned ON and the encoding is set to
 //      the encoding of the parent frame, which is also auto-detected.
 //   Note that condition #2 is NOT satisfied unless parent-child frame
 //   relationship is compliant to the same-origin policy. If they're from
 //   different domains, |m_source| would not be set to EncodingFromParentFrame
 //   in the first place. 
@@ skipping 25 matching lines @@
     // we have already done some decoding. However, it's not possible
     // to avoid in a sense in two cases below because triggering conditions
     // for both cases depend on the information that won't be available
     // until we do partial read. 
     // The first case had better be removed altogether (see bug 21990)
     // or at least be made to be invoked only when the encoding detection
     // is turned on. 
     // Do the auto-detect 1) using Japanese detector if our default encoding is
     // one of the Japanese detector or 2) using detectTextEncoding if encoding
     // detection is turned on.
+#if !PLATFORM(CHROMIUM)
     if (m_source != UserChosenEncoding && m_source != AutoDetectedEncoding && m_encoding.isJapanese())
         detectJapaneseEncoding(data, len);
     else if (shouldAutoDetect()) {
+#else
+    if (shouldAutoDetect()) {
+#endif
         TextEncoding detectedEncoding;
         if (detectTextEncoding(data, len, m_hintEncoding, &detectedEncoding))
             setEncoding(detectedEncoding, AutoDetectedEncoding);
     }
 
     ASSERT(m_encoding.isValid());
 
     if (!m_codec)
         m_codec.set(newTextCodec(m_encoding).release());
 
@@ skipping 28 matching lines @@
         m_codec.set(newTextCodec(m_encoding).release());
 
     String result = m_codec->decode(m_buffer.data(), m_buffer.size(), true, m_contentType == XML && !m_useLenientXMLDecoding, m_sawError);
     m_buffer.clear();
     m_codec.clear();
     m_checkedForBOM = false; // Skip BOM again when re-decoding.
     return result;
 }
 
 }