Migrate error messages, part 8.

src/runtime/runtime-typedarray.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/arguments.h"
 #include "src/messages.h"
 #include "src/runtime/runtime.h"
 #include "src/runtime/runtime-utils.h"
@@ skipping 62 matching lines @@
   DCHECK(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, holder, 0);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(byteLength, 1);
   if (!holder->byte_length()->IsUndefined()) {
     // ArrayBuffer is already initialized; probably a fuzz test.
     return *holder;
   }
   size_t allocated_length = 0;
   if (!TryNumberToSize(isolate, *byteLength, &allocated_length)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("invalid_array_buffer_length",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kInvalidArrayBufferLength));
   }
   if (!Runtime::SetupArrayBufferAllocatingData(isolate, holder,
                                                allocated_length)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("invalid_array_buffer_length",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kInvalidArrayBufferLength));
   }
   return *holder;
 }
 
 
 RUNTIME_FUNCTION(Runtime_ArrayBufferGetByteLength) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(JSArrayBuffer, holder, 0);
   return holder->byte_length();
@@ skipping 106 matching lines @@
     RUNTIME_ASSERT(array_buffer_byte_length - byte_offset >= byte_length);
   } else {
     RUNTIME_ASSERT(maybe_buffer->IsNull());
   }
 
   RUNTIME_ASSERT(byte_length % element_size == 0);
   size_t length = byte_length / element_size;
 
   if (length > static_cast<unsigned>(Smi::kMaxValue)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("invalid_typed_array_length",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kInvalidTypedArrayLength));
   }
 
   // All checks are done, now we can modify objects.
 
   DCHECK(holder->GetInternalFieldCount() ==
          v8::ArrayBufferView::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBufferView::kInternalFieldCount; i++) {
     holder->SetInternalField(i, Smi::FromInt(0));
   }
   Handle<Object> length_obj = isolate->factory()->NewNumberFromSize(length);
@@ skipping 55 matching lines @@
   if (source->IsJSTypedArray() &&
       JSTypedArray::cast(*source)->type() == array_type) {
     length_obj = Handle<Object>(JSTypedArray::cast(*source)->length(), isolate);
   }
   size_t length = 0;
   RUNTIME_ASSERT(TryNumberToSize(isolate, *length_obj, &length));
 
   if ((length > static_cast<unsigned>(Smi::kMaxValue)) ||
       (length > (kMaxInt / element_size))) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("invalid_typed_array_length",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kInvalidTypedArrayLength));
   }
   size_t byte_length = length * element_size;
 
   DCHECK(holder->GetInternalFieldCount() ==
          v8::ArrayBufferView::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBufferView::kInternalFieldCount; i++) {
     holder->SetInternalField(i, Smi::FromInt(0));
   }
 
   // NOTE: not initializing backing store.
   // We assume that the caller of this function will initialize holder
   // with the loop
   //      for(i = 0; i < length; i++) { holder[i] = source[i]; }
   // We assume that the caller of this function is always a typed array
   // constructor.
   // If source is a typed array, this loop will always run to completion,
   // so we are sure that the backing store will be initialized.
   // Otherwise, the indexing operation might throw, so the loop will not
   // run to completion and the typed array might remain partly initialized.
   // However we further assume that the caller of this function is a typed array
   // constructor, and the exception will propagate out of the constructor,
   // therefore uninitialized memory will not be accessible by a user program.
   //
   // TODO(dslomov): revise this once we support subclassing.
 
   if (!Runtime::SetupArrayBufferAllocatingData(isolate, buffer, byte_length,
                                                false)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("invalid_array_buffer_length",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kInvalidArrayBufferLength));
   }
 
   holder->set_buffer(*buffer);
   holder->set_byte_offset(Smi::FromInt(0));
   Handle<Object> byte_length_obj(
       isolate->factory()->NewNumberFromSize(byte_length));
   holder->set_byte_length(*byte_length_obj);
   holder->set_length(*length_obj);
 
   Handle<ExternalArray> elements = isolate->factory()->NewExternalArray(
@@ skipping 78 matching lines @@
   Handle<JSTypedArray> source(JSTypedArray::cast(*source_obj));
   size_t offset = 0;
   RUNTIME_ASSERT(TryNumberToSize(isolate, *offset_obj, &offset));
   size_t target_length = NumberToSize(isolate, target->length());
   size_t source_length = NumberToSize(isolate, source->length());
   size_t target_byte_length = NumberToSize(isolate, target->byte_length());
   size_t source_byte_length = NumberToSize(isolate, source->byte_length());
   if (offset > target_length || offset + source_length > target_length ||
       offset + source_length < offset) {  // overflow
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewRangeError("typed_array_set_source_too_large",
-                               HandleVector<Object>(NULL, 0)));
+        isolate, NewRangeError(MessageTemplate::kTypedArraySetSourceTooLarge));
   }
 
   size_t target_offset = NumberToSize(isolate, target->byte_offset());
   size_t source_offset = NumberToSize(isolate, source->byte_offset());
   uint8_t* target_base =
       static_cast<uint8_t*>(target->GetBuffer()->backing_store()) +
       target_offset;
   uint8_t* source_base =
       static_cast<uint8_t*>(source->GetBuffer()->backing_store()) +
       source_offset;
@@ skipping 171 matching lines @@
       static_cast<uint8_t*>(buffer->backing_store()) + buffer_offset;
   if (NeedToFlipBytes(is_little_endian)) {
     FlipBytes<sizeof(T)>(target, value.bytes);
   } else {
     CopyBytes<sizeof(T)>(target, value.bytes);
   }
   return true;
 }
 
 
-#define DATA_VIEW_GETTER(TypeName, Type, Converter)                   \
-  RUNTIME_FUNCTION(Runtime_DataViewGet##TypeName) {                   \
-    HandleScope scope(isolate);                                       \
-    DCHECK(args.length() == 3);                                       \
-    CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);                \
-    CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1);                     \
-    CONVERT_BOOLEAN_ARG_CHECKED(is_little_endian, 2);                 \
-    Type result;                                                      \
-    if (DataViewGetValue(isolate, holder, offset, is_little_endian,   \
-                         &result)) {                                  \
-      return *isolate->factory()->Converter(result);                  \
-    } else {                                                          \
-      THROW_NEW_ERROR_RETURN_FAILURE(                                 \
-          isolate, NewRangeError("invalid_data_view_accessor_offset", \
-                                 HandleVector<Object>(NULL, 0)));     \
-    }                                                                 \
+#define DATA_VIEW_GETTER(TypeName, Type, Converter)                        \
+  RUNTIME_FUNCTION(Runtime_DataViewGet##TypeName) {                        \
+    HandleScope scope(isolate);                                            \
+    DCHECK(args.length() == 3);                                            \
+    CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);                     \
+    CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1);                          \
+    CONVERT_BOOLEAN_ARG_CHECKED(is_little_endian, 2);                      \
+    Type result;                                                           \
+    if (DataViewGetValue(isolate, holder, offset, is_little_endian,        \
+                         &result)) {                                       \
+      return *isolate->factory()->Converter(result);                       \
+    } else {                                                               \
+      THROW_NEW_ERROR_RETURN_FAILURE(                                      \
+          isolate,                                                         \
+          NewRangeError(MessageTemplate::kInvalidDataViewAccessorOffset)); \
+    }                                                                      \
   }
 
 DATA_VIEW_GETTER(Uint8, uint8_t, NewNumberFromUint)
 DATA_VIEW_GETTER(Int8, int8_t, NewNumberFromInt)
 DATA_VIEW_GETTER(Uint16, uint16_t, NewNumberFromUint)
 DATA_VIEW_GETTER(Int16, int16_t, NewNumberFromInt)
 DATA_VIEW_GETTER(Uint32, uint32_t, NewNumberFromUint)
 DATA_VIEW_GETTER(Int32, int32_t, NewNumberFromInt)
 DATA_VIEW_GETTER(Float32, float, NewNumber)
 DATA_VIEW_GETTER(Float64, double, NewNumber)
@@ skipping 46 matching lines @@
   return static_cast<float>(value);
 }
 
 
 template <>
 double DataViewConvertValue<double>(double value) {
   return value;
 }
 
 
-#define DATA_VIEW_SETTER(TypeName, Type)                                  \
-  RUNTIME_FUNCTION(Runtime_DataViewSet##TypeName) {                       \
-    HandleScope scope(isolate);                                           \
-    DCHECK(args.length() == 4);                                           \
-    CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);                    \
-    CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1);                         \
-    CONVERT_NUMBER_ARG_HANDLE_CHECKED(value, 2);                          \
-    CONVERT_BOOLEAN_ARG_CHECKED(is_little_endian, 3);                     \
-    Type v = DataViewConvertValue<Type>(value->Number());                 \
-    if (DataViewSetValue(isolate, holder, offset, is_little_endian, v)) { \
-      return isolate->heap()->undefined_value();                          \
-    } else {                                                              \
-      THROW_NEW_ERROR_RETURN_FAILURE(                                     \
-          isolate, NewRangeError("invalid_data_view_accessor_offset",     \
-                                 HandleVector<Object>(NULL, 0)));         \
-    }                                                                     \
+#define DATA_VIEW_SETTER(TypeName, Type)                                   \
+  RUNTIME_FUNCTION(Runtime_DataViewSet##TypeName) {                        \
+    HandleScope scope(isolate);                                            \
+    DCHECK(args.length() == 4);                                            \
+    CONVERT_ARG_HANDLE_CHECKED(JSDataView, holder, 0);                     \
+    CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1);                          \
+    CONVERT_NUMBER_ARG_HANDLE_CHECKED(value, 2);                           \
+    CONVERT_BOOLEAN_ARG_CHECKED(is_little_endian, 3);                      \
+    Type v = DataViewConvertValue<Type>(value->Number());                  \
+    if (DataViewSetValue(isolate, holder, offset, is_little_endian, v)) {  \
+      return isolate->heap()->undefined_value();                           \
+    } else {                                                               \
+      THROW_NEW_ERROR_RETURN_FAILURE(                                      \
+          isolate,                                                         \
+          NewRangeError(MessageTemplate::kInvalidDataViewAccessorOffset)); \
+    }                                                                      \
   }
 
 DATA_VIEW_SETTER(Uint8, uint8_t)
 DATA_VIEW_SETTER(Int8, int8_t)
 DATA_VIEW_SETTER(Uint16, uint16_t)
 DATA_VIEW_SETTER(Int16, int16_t)
 DATA_VIEW_SETTER(Uint32, uint32_t)
 DATA_VIEW_SETTER(Int32, int32_t)
 DATA_VIEW_SETTER(Float32, float)
 DATA_VIEW_SETTER(Float64, double)
 
 #undef DATA_VIEW_SETTER
 }
 }  // namespace v8::internal