Fix BOM handling w/ bookmark + streaming parsing.

Source/bindings/core/v8/ScriptStreamer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
@@ skipping 151 matching lines @@
 class SourceStream : public v8::ScriptCompiler::ExternalSourceStream {
     WTF_MAKE_NONCOPYABLE(SourceStream);
 public:
     SourceStream()
         : v8::ScriptCompiler::ExternalSourceStream()
         , m_cancelled(false)
         , m_finished(false)
         , m_queueLeadPosition(0)
         , m_queueTailPosition(0)
         , m_bookmarkPosition(0)
+        , m_lengthOfBOM(0)
     {
     }
 
     virtual ~SourceStream() override { }
 
     // Called by V8 on a background thread. Should block until we can return
     // some data.
     size_t GetMoreData(const uint8_t** src) override
     {
         ASSERT(!isMainThread());
@@ skipping 12 matching lines @@
         }
         m_queueLeadPosition += length;
         return length;
     }
 
     // Called by V8 on background thread.
     bool SetBookmark() override
     {
         ASSERT(!isMainThread());
         m_bookmarkPosition = m_queueLeadPosition;
-        return m_bookmarkPosition != 0; // Don't mess with BOM.
+        return true;
     }
 
     // Called by V8 on background thread.
     void ResetToBookmark() override
     {
         ASSERT(!isMainThread());
         {
             MutexLocker locker(m_mutex);
             m_queueLeadPosition = m_bookmarkPosition;
-            m_queueTailPosition = m_bookmarkPosition;
+            // See comments at m_lengthOfBOM declaration below for why
+            // we need this here.
+            m_queueTailPosition = m_bookmarkPosition + m_lengthOfBOM;
             m_dataQueue.clear();
         }
 
         // Inform main thread to re-queue the data.
         Platform::current()->mainThread()->taskRunner()->postTask(
             FROM_HERE, bind(&SourceStream::fetchDataFromResourceBuffer, this, 0));
     }
 
     void didFinishLoading()
     {
@@ skipping 76 matching lines @@
                 // FIXME: Here we can limit based on the total length, if it turns
                 // out that we don't want to give all the data we have (memory
                 // vs. speed).
                 chunks.append(data);
                 chunkLengths.append(length);
                 dataLength += length;
                 m_queueTailPosition += length;
             }
         }
 
+        if (lengthOfBOM > 0) {
+            ASSERT(!m_lengthOfBOM); // There should be only one BOM.
+            m_lengthOfBOM = lengthOfBOM;
+        }
+
         // Copy the data chunks into a new buffer, since we're going to give the
         // data to a background thread.
         if (dataLength > lengthOfBOM) {
             dataLength -= lengthOfBOM;
             uint8_t* copiedData = new uint8_t[dataLength];
             unsigned offset = 0;
             for (size_t i = 0; i < chunks.size(); ++i) {
                 memcpy(copiedData + offset, chunks[i] + lengthOfBOM, chunkLengths[i] - lengthOfBOM);
                 offset += chunkLengths[i] - lengthOfBOM;
                 // BOM is only in the first chunk
@@ skipping 18 matching lines @@
     RefPtr<SharedBuffer> m_resourceBuffer; // Only used by the main thread.
 
     // The queue contains the data to be passed to the V8 thread.
     //   queueLeadPosition: data we have handed off to the V8 thread.
     //   queueTailPosition: end of data we have enqued in the queue.
     //   bookmarkPosition: position of the bookmark.
     SourceStreamDataQueue m_dataQueue; // Thread safe.
     unsigned m_queueLeadPosition; // Only used by v8 thread.
     unsigned m_queueTailPosition; // Used by both threads; guarded by m_mutex.
     unsigned m_bookmarkPosition; // Only used by v8 thread.
+
+    // BOM (Unicode Byte Order Mark) handling:
+    // This class is responsible for stripping out the BOM, since Chrome
+    // delivers the input stream potentially with BOM, but V8 doesn't want
+    // to see the BOM. This is mostly easy to do, except for a funky edge
+    // condition with bookmarking:
+    // - m_queueLeadPosition counts the bytes that V8 has received
+    //   (i.e., without BOM)
+    // - m_queueTailPosition counts the bytes that Chrome has sent
+    //   (i.e., with BOM)
+    // So when resetting the bookmark, we have to adjust the lead position
+    // to account for the BOM (which happens implicitly in the regular
+    // streaming case).
+    // We store this separately, to avoid having to guard all
+    // m_queueLeadPosition references with a mutex.
+    unsigned m_lengthOfBOM; // Used by both threads; guarded by m_mutex.
 };
 
 size_t ScriptStreamer::kSmallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript& script, PendingScript::Type scriptType, Settings* settings, ScriptState* scriptState)
 {
     // We don't yet know whether the script will really be streamed. E.g.,
     // suppressing streaming for short scripts is done later. Record only the
     // sure negative cases here.
     bool startedStreaming = startStreamingInternal(script, scriptType, settings, scriptState);
@@ skipping 281 matching lines @@
 
     // The Resource might go out of scope if the script is no longer
     // needed. This makes PendingScript notify the ScriptStreamer when it is
     // destroyed.
     script.setStreamer(ScriptStreamer::create(resource, scriptType, scriptState, compileOption));
 
     return true;
 }
 
 } // namespace blink