Fix errors caused by unsafe conversions to/from size_t

third_party/WebKit/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 "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
@@ skipping 279 matching lines @@
     }
 
     void fetchDataFromResourceBuffer(size_t lengthOfBOM)
     {
         ASSERT(isMainThread());
         MutexLocker locker(m_mutex); // For m_cancelled + m_queueTailPosition.
 
         // Get as much data from the ResourceBuffer as we can.
         const char* data = 0;
         Vector<const char*> chunks;
-        Vector<unsigned> chunkLengths;
+        Vector<size_t> chunkLengths;
         size_t dataLength = 0;
 
         if (!m_cancelled) {
-            while (unsigned length = m_resourceBuffer->getSomeData(data, m_queueTailPosition)) {
+            while (size_t length = m_resourceBuffer->getSomeData(data, m_queueTailPosition)) {
                 // 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;
+            size_t 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
                 lengthOfBOM = 0;
             }
             m_dataQueue.produce(copiedData, dataLength);
         }
 
         if (m_finished || m_cancelled)
             m_dataQueue.finish();
     }
 
     // For coordinating between the main thread and background thread tasks.
     // Guards m_cancelled and m_queueTailPosition.
     Mutex m_mutex;
 
     // The shared buffer containing the resource data + state variables.
     // Used by both threads, guarded by m_mutex.
     bool m_cancelled;
     bool m_finished;
 
     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.
+    size_t m_queueLeadPosition; // Only used by v8 thread.
+    size_t m_queueTailPosition; // Used by both threads; guarded by m_mutex.
+    size_t 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 m_lengthOfBOM; // Used by both threads; guarded by m_mutex.
 
     OwnPtr<WebTaskRunner> m_loadingTaskRunner;
 };
 
 size_t ScriptStreamer::kSmallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript& script, PendingScript::Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     // 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
@@ skipping 92 matching lines @@
 
         // Encoding should be detected only when we have some data. It's
         // possible that resource->encoding() returns a different encoding
         // before the loading has started and after we got some data.  In
         // addition, check for byte order marks. Note that checking the byte
         // order mark might change the encoding. We cannot decode the full text
         // here, because it might contain incomplete UTF-8 characters. Also note
         // that have at least kSmallScriptThreshold worth of data, which is more
         // than enough for detecting a BOM.
         const char* data = 0;
-        unsigned length = resource->resourceBuffer()->getSomeData(data, 0);
+        size_t length = resource->resourceBuffer()->getSomeData(data, static_cast<size_t>(0));
 
         OwnPtr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
         lengthOfBOM = decoder->checkForBOM(data, length);
 
         // Maybe the encoding changed because we saw the BOM; get the encoding
         // from the decoder.
         if (!convertEncoding(decoder->encoding().name(), &m_encoding)) {
             suppressStreaming();
             Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), EncodingNotSupported, NotStreamingReasonEnd);
             Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
@@ skipping 171 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, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink