Remove Factory::NewStringFromASCII method.

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/feedback-vector-inl.h"  // for include "src/factory.h"
 #include "src/objects-inl.h"
 #include "src/parsing/scanner-character-streams.h"
 #include "src/parsing/scanner.h"
 #include "test/cctest/cctest.h"
@@ skipping 293 matching lines @@
     }
     TestExternalResource resource(uc16_buffer.get(), length);
     i::Handle<i::String> uc16_string(
         factory->NewExternalStringFromTwoByte(&resource).ToHandleChecked());
     std::unique_ptr<i::Utf16CharacterStream> uc16_stream(
         i::ScannerStream::For(uc16_string, start, end));
     TestCharacterStream(one_byte_source, uc16_stream.get(), length, start, end);
   }
 
   // 1-byte external string
-  i::Vector<const char> one_byte_vector(one_byte_source,
-                                        static_cast<int>(length));
+  i::Vector<const uint8_t> one_byte_vector =
+      i::OneByteVector(one_byte_source, static_cast<int>(length));
   i::Handle<i::String> one_byte_string =
-      factory->NewStringFromAscii(one_byte_vector).ToHandleChecked();
+      factory->NewStringFromOneByte(one_byte_vector).ToHandleChecked();
   {
     TestExternalOneByteResource one_byte_resource(one_byte_source, length);
     i::Handle<i::String> ext_one_byte_string(
         factory->NewExternalStringFromOneByte(&one_byte_resource)
             .ToHandleChecked());
     std::unique_ptr<i::Utf16CharacterStream> one_byte_stream(
         i::ScannerStream::For(ext_one_byte_string, start, end));
     TestCharacterStream(one_byte_source, one_byte_stream.get(), length, start,
                         end);
   }
@@ skipping 15 matching lines @@
     TestCharacterStream(one_byte_source, two_byte_string_stream.get(), length,
                         start, end);
   }
 
   // Streaming has no notion of start/end, so let's skip streaming tests for
   // these cases.
   if (start != 0 || end != length) return;
 
   // 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());
+    const uint8_t* data = one_byte_vector.begin();
+    const uint8_t* data_end = 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,
                               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, 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());
+    const uint8_t* data = one_byte_vector.begin();
+    const uint8_t* data_end = 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,
                               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, nullptr));
@@ skipping 58 matching lines @@
     // 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, nullptr));
     for (size_t i = 0; i < len; i++) {
       CHECK_EQ(unicode[i], stream->Advance());
     }
     CHECK_EQ(i::Utf16CharacterStream::kEndOfInput, stream->Advance());
   }
 }