[counters] Move waiting for more data from background-parsing into callbacks

test/cctest/parsing/test-scanner-streams.cc

 // Copyright 2016 the V8 project 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 "src/factory.h"  // for i::Factory::NewExternalStringFrom*Byte
 #include "src/objects-inl.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/parsing/scanner.h"
 #include "src/type-feedback-vector-inl.h"  // for include "src/factory.h"
 #include "test/cctest/cctest.h"
@@ skipping 82 matching lines @@
 const uint16_t unicode_ucs2[] = {97,    98,  99,  228, 10784, 55357,
                                  56489, 100, 101, 102, 0};
 
 }  // anonymous namespace
 
 TEST(Utf8StreamAsciiOnly) {
   const char* chunks[] = {"abc", "def", "ghi", ""};
   ChunkSource chunk_source(chunks);
   std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
       v8::internal::ScannerStream::For(
-          &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+          &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
   // Read the data without dying.
   v8::internal::uc32 c;
   do {
     c = stream->Advance();
   } while (c != v8::internal::Utf16CharacterStream::kEndOfInput);
 }
 
 TEST(Utf8StreamBOM) {
   // Construct test string w/ UTF-8 BOM (byte order mark)
   char data[3 + arraysize(unicode_utf8)] = {"\xef\xbb\xbf"};
   strncpy(data + 3, unicode_utf8, arraysize(unicode_utf8));
 
   const char* chunks[] = {data, "\0"};
   ChunkSource chunk_source(chunks);
   std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
       v8::internal::ScannerStream::For(
-          &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+          &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
   // Read the data without tripping over the BOM.
   for (size_t i = 0; unicode_ucs2[i]; i++) {
     CHECK_EQ(unicode_ucs2[i], stream->Advance());
   }
   CHECK_EQ(v8::internal::Utf16CharacterStream::kEndOfInput, stream->Advance());
 
   // Make sure seek works.
   stream->Seek(0);
   CHECK_EQ(unicode_ucs2[0], stream->Advance());
 
   stream->Seek(5);
   CHECK_EQ(unicode_ucs2[5], stream->Advance());
 }
 
 TEST(Utf8SplitBOM) {
   // Construct chunks with a BOM split into two chunks.
   char partial_bom[] = "\xef\xbb";
   char data[1 + arraysize(unicode_utf8)] = {"\xbf"};
   strncpy(data + 1, unicode_utf8, arraysize(unicode_utf8));
 
   {
     const char* chunks[] = {partial_bom, data, "\0"};
     ChunkSource chunk_source(chunks);
     std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
         v8::internal::ScannerStream::For(
-            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
     // Read the data without tripping over the BOM.
     for (size_t i = 0; unicode_ucs2[i]; i++) {
       CHECK_EQ(unicode_ucs2[i], stream->Advance());
     }
   }
 
   // And now with single-byte BOM chunks.
   char bom_byte_1[] = "\xef";
   char bom_byte_2[] = "\xbb";
   {
     const char* chunks[] = {bom_byte_1, bom_byte_2, data, "\0"};
     ChunkSource chunk_source(chunks);
     std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
         v8::internal::ScannerStream::For(
-            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
     // Read the data without tripping over the BOM.
     for (size_t i = 0; unicode_ucs2[i]; i++) {
       CHECK_EQ(unicode_ucs2[i], stream->Advance());
     }
   }
 }
 
 TEST(Utf8ChunkBoundaries) {
   // Test utf-8 parsing at chunk boundaries.
 
   // Split the test string at each byte and pass it to the stream. This way,
   // we'll have a split at each possible boundary.
   size_t len = strlen(unicode_utf8);
   char buffer[arraysize(unicode_utf8) + 3];
   for (size_t i = 1; i < len; i++) {
     // Copy source string into buffer, splitting it at i.
     // Then add three chunks, 0..i-1, i..strlen-1, empty.
     strncpy(buffer, unicode_utf8, i);
     strncpy(buffer + i + 1, unicode_utf8 + i, len - i);
     buffer[i] = '\0';
     buffer[len + 1] = '\0';
     buffer[len + 2] = '\0';
     const char* chunks[] = {buffer, buffer + i + 1, buffer + len + 2};
 
     ChunkSource chunk_source(chunks);
     std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
         v8::internal::ScannerStream::For(
-            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
     for (size_t i = 0; unicode_ucs2[i]; i++) {
       CHECK_EQ(unicode_ucs2[i], stream->Advance());
     }
     CHECK_EQ(v8::internal::Utf16CharacterStream::kEndOfInput,
              stream->Advance());
   }
 }
 
 TEST(Utf8SingleByteChunks) {
   // Have each byte as a single-byte chunk.
   size_t len = strlen(unicode_utf8);
   char buffer[arraysize(unicode_utf8) + 4];
   for (size_t i = 1; i < len - 1; i++) {
     // Copy source string into buffer, make a single-byte chunk at i.
     strncpy(buffer, unicode_utf8, i);
     strncpy(buffer + i + 3, unicode_utf8 + i + 1, len - i - 1);
     buffer[i] = '\0';
     buffer[i + 1] = unicode_utf8[i];
     buffer[i + 2] = '\0';
     buffer[len + 2] = '\0';
     buffer[len + 3] = '\0';
     const char* chunks[] = {buffer, buffer + i + 1, buffer + i + 3,
                             buffer + len + 3};
 
     ChunkSource chunk_source(chunks);
     std::unique_ptr<v8::internal::Utf16CharacterStream> stream(
         v8::internal::ScannerStream::For(
-            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8));
+            &chunk_source, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
 
     for (size_t j = 0; unicode_ucs2[j]; j++) {
       CHECK_EQ(unicode_ucs2[j], stream->Advance());
     }
     CHECK_EQ(v8::internal::Utf16CharacterStream::kEndOfInput,
              stream->Advance());
   }
 }
 
 #define CHECK_EQU(v1, v2) CHECK_EQ(static_cast<int>(v1), static_cast<int>(v2))
@@ skipping 111 matching lines @@
   // 1-byte streaming stream, single + many chunks.
   {
     const uint8_t* data =
         reinterpret_cast<const uint8_t*>(one_byte_vector.begin());
     const uint8_t* data_end =
         reinterpret_cast<const uint8_t*>(one_byte_vector.end());
 
     ChunkSource single_chunk(data, data_end - data, false);
     std::unique_ptr<i::Utf16CharacterStream> one_byte_streaming_stream(
         i::ScannerStream::For(&single_chunk,
-                              v8::ScriptCompiler::StreamedSource::ONE_BYTE));
+                              v8::ScriptCompiler::StreamedSource::ONE_BYTE,
+                              nullptr));
     TestCharacterStream(one_byte_source, one_byte_streaming_stream.get(),
                         length, start, end);
 
     ChunkSource many_chunks(data, data_end - data, true);
     one_byte_streaming_stream.reset(i::ScannerStream::For(
-        &many_chunks, v8::ScriptCompiler::StreamedSource::ONE_BYTE));
+        &many_chunks, v8::ScriptCompiler::StreamedSource::ONE_BYTE, nullptr));
     TestCharacterStream(one_byte_source, one_byte_streaming_stream.get(),
                         length, start, end);
   }
 
   // UTF-8 streaming stream, single + many chunks.
   {
     const uint8_t* data =
         reinterpret_cast<const uint8_t*>(one_byte_vector.begin());
     const uint8_t* data_end =
         reinterpret_cast<const uint8_t*>(one_byte_vector.end());
     ChunkSource chunks(data, data_end - data, false);
     std::unique_ptr<i::Utf16CharacterStream> utf8_streaming_stream(
-        i::ScannerStream::For(&chunks,
-                              v8::ScriptCompiler::StreamedSource::UTF8));
+        i::ScannerStream::For(&chunks, v8::ScriptCompiler::StreamedSource::UTF8,
+                              nullptr));
     TestCharacterStream(one_byte_source, utf8_streaming_stream.get(), length,
                         start, end);
 
     ChunkSource many_chunks(data, data_end - data, true);
     utf8_streaming_stream.reset(i::ScannerStream::For(
-        &many_chunks, v8::ScriptCompiler::StreamedSource::UTF8));
+        &many_chunks, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
     TestCharacterStream(one_byte_source, utf8_streaming_stream.get(), length,
                         start, end);
   }
 
   // 2-byte streaming stream, single + many chunks.
   {
     const uint8_t* data =
         reinterpret_cast<const uint8_t*>(two_byte_vector.begin());
     const uint8_t* data_end =
         reinterpret_cast<const uint8_t*>(two_byte_vector.end());
     ChunkSource chunks(data, data_end - data, false);
     std::unique_ptr<i::Utf16CharacterStream> two_byte_streaming_stream(
-        i::ScannerStream::For(&chunks,
-                              v8::ScriptCompiler::StreamedSource::TWO_BYTE));
+        i::ScannerStream::For(
+            &chunks, v8::ScriptCompiler::StreamedSource::TWO_BYTE, nullptr));
     TestCharacterStream(one_byte_source, two_byte_streaming_stream.get(),
                         length, start, end);
 
     ChunkSource many_chunks(data, data_end - data, true);
     two_byte_streaming_stream.reset(i::ScannerStream::For(
-        &many_chunks, v8::ScriptCompiler::StreamedSource::TWO_BYTE));
+        &many_chunks, v8::ScriptCompiler::StreamedSource::TWO_BYTE, nullptr));
     TestCharacterStream(one_byte_source, two_byte_streaming_stream.get(),
                         length, start, end);
   }
 }
 
 TEST(CharacterStreams) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = v8::Context::New(isolate);
   v8::Context::Scope context_scope(context);
@@ skipping 21 matching lines @@
   const uint16_t unicode[] = {65, 65533, 97, 100};
 
   // Run the test for all sub-strings 0..N of bytes, to make sure we hit the
   // error condition in and at chunk boundaries.
   for (size_t len = 0; len < arraysize(bytes); len++) {
     // Read len bytes from bytes, and compare against the expected unicode
     // characters. Expect kBadChar ( == Unicode replacement char == code point
     // 65533) instead of the incorrectly coded Latin1 char.
     ChunkSource chunks(bytes, len, false);
     std::unique_ptr<i::Utf16CharacterStream> stream(i::ScannerStream::For(
-        &chunks, v8::ScriptCompiler::StreamedSource::UTF8));
+        &chunks, v8::ScriptCompiler::StreamedSource::UTF8, nullptr));
     for (size_t i = 0; i < len; i++) {
       CHECK_EQ(unicode[i], stream->Advance());
     }
     CHECK_EQ(i::Utf16CharacterStream::kEndOfInput, stream->Advance());
   }
 }