Remove unused isolate parameter from NumberToSize and TryNumberToSize

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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/factory.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
@@ skipping 20 matching lines @@
 
   if (source->was_neutered() || target->was_neutered()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kDetachedOperation,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "ArrayBuffer.prototype.slice")));
   }
 
   CHECK(!source.is_identical_to(target));
   size_t start = 0, target_length = 0;
-  CHECK(TryNumberToSize(isolate, *first, &start));
-  CHECK(TryNumberToSize(isolate, *new_length, &target_length));
-  CHECK(NumberToSize(isolate, target->byte_length()) >= target_length);
+  CHECK(TryNumberToSize(*first, &start));
+  CHECK(TryNumberToSize(*new_length, &target_length));
+  CHECK(NumberToSize(target->byte_length()) >= target_length);
 
   if (target_length == 0) return isolate->heap()->undefined_value();
 
-  size_t source_byte_length = NumberToSize(isolate, source->byte_length());
+  size_t source_byte_length = NumberToSize(source->byte_length());
   CHECK(start <= source_byte_length);
   CHECK(source_byte_length - start >= target_length);
   uint8_t* source_data = reinterpret_cast<uint8_t*>(source->backing_store());
   uint8_t* target_data = reinterpret_cast<uint8_t*>(target->backing_store());
   CopyBytes(target_data, source_data + start, target_length);
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_ArrayBufferNeuter) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, array_buffer, 0);
   if (array_buffer->backing_store() == NULL) {
     CHECK(Smi::FromInt(0) == array_buffer->byte_length());
     return isolate->heap()->undefined_value();
   }
   // Shared array buffers should never be neutered.
   CHECK(!array_buffer->is_shared());
   DCHECK(!array_buffer->is_external());
   void* backing_store = array_buffer->backing_store();
-  size_t byte_length = NumberToSize(isolate, array_buffer->byte_length());
+  size_t byte_length = NumberToSize(array_buffer->byte_length());
   array_buffer->set_is_external(true);
   isolate->heap()->UnregisterArrayBuffer(*array_buffer);
   array_buffer->Neuter();
   isolate->array_buffer_allocator()->Free(backing_store, byte_length);
   return isolate->heap()->undefined_value();
 }
 
 
 void Runtime::ArrayIdToTypeAndSize(int arrayId, ExternalArrayType* array_type,
                                    ElementsKind* fixed_elements_kind,
@@ skipping 30 matching lines @@
 
   ExternalArrayType array_type = kExternalInt8Array;  // Bogus initialization.
   size_t element_size = 1;                            // Bogus initialization.
   ElementsKind fixed_elements_kind = INT8_ELEMENTS;  // Bogus initialization.
   Runtime::ArrayIdToTypeAndSize(arrayId, &array_type, &fixed_elements_kind,
                                 &element_size);
   CHECK(holder->map()->elements_kind() == fixed_elements_kind);
 
   size_t byte_offset = 0;
   size_t byte_length = 0;
-  CHECK(TryNumberToSize(isolate, *byte_offset_object, &byte_offset));
-  CHECK(TryNumberToSize(isolate, *byte_length_object, &byte_length));
+  CHECK(TryNumberToSize(*byte_offset_object, &byte_offset));
+  CHECK(TryNumberToSize(*byte_length_object, &byte_length));
 
   if (maybe_buffer->IsJSArrayBuffer()) {
     Handle<JSArrayBuffer> buffer = Handle<JSArrayBuffer>::cast(maybe_buffer);
-    size_t array_buffer_byte_length =
-        NumberToSize(isolate, buffer->byte_length());
+    size_t array_buffer_byte_length = NumberToSize(buffer->byte_length());
     CHECK(byte_offset <= array_buffer_byte_length);
     CHECK(array_buffer_byte_length - byte_offset >= byte_length);
   } else {
     CHECK(maybe_buffer->IsNull(isolate));
   }
 
   CHECK(byte_length % element_size == 0);
   size_t length = byte_length / element_size;
 
   if (length > static_cast<unsigned>(Smi::kMaxValue)) {
@@ skipping 60 matching lines @@
 
   CHECK(holder->map()->elements_kind() == fixed_elements_kind);
 
   Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
   size_t length = 0;
   if (source->IsJSTypedArray() &&
       JSTypedArray::cast(*source)->type() == array_type) {
     length_obj = handle(JSTypedArray::cast(*source)->length(), isolate);
     length = JSTypedArray::cast(*source)->length_value();
   } else {
-    CHECK(TryNumberToSize(isolate, *length_obj, &length));
+    CHECK(TryNumberToSize(*length_obj, &length));
   }
 
   if ((length > static_cast<unsigned>(Smi::kMaxValue)) ||
       (length > (kMaxInt / element_size))) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewRangeError(MessageTemplate::kInvalidTypedArrayLength));
   }
   size_t byte_length = length * element_size;
 
   DCHECK_EQ(v8::ArrayBufferView::kInternalFieldCount,
@@ skipping 36 matching lines @@
           static_cast<int>(length), array_type,
           static_cast<uint8_t*>(buffer->backing_store()));
   holder->set_elements(*elements);
 
   if (source->IsJSTypedArray()) {
     Handle<JSTypedArray> typed_array(JSTypedArray::cast(*source));
 
     if (typed_array->type() == holder->type()) {
       uint8_t* backing_store =
           static_cast<uint8_t*>(typed_array->GetBuffer()->backing_store());
-      size_t source_byte_offset =
-          NumberToSize(isolate, typed_array->byte_offset());
+      size_t source_byte_offset = NumberToSize(typed_array->byte_offset());
       memcpy(buffer->backing_store(), backing_store + source_byte_offset,
              byte_length);
       return isolate->heap()->true_value();
     }
   }
 
   return isolate->heap()->false_value();
 }
 
 
@@ skipping 45 matching lines @@
   if (!args[1]->IsJSTypedArray())
     return Smi::FromInt(TYPED_ARRAY_SET_NON_TYPED_ARRAY);
 
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, target_obj, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, source_obj, 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset_obj, 2);
 
   Handle<JSTypedArray> target(JSTypedArray::cast(*target_obj));
   Handle<JSTypedArray> source(JSTypedArray::cast(*source_obj));
   size_t offset = 0;
-  CHECK(TryNumberToSize(isolate, *offset_obj, &offset));
+  CHECK(TryNumberToSize(*offset_obj, &offset));
   size_t target_length = target->length_value();
   size_t source_length = source->length_value();
-  size_t target_byte_length = NumberToSize(isolate, target->byte_length());
-  size_t source_byte_length = NumberToSize(isolate, source->byte_length());
+  size_t target_byte_length = NumberToSize(target->byte_length());
+  size_t source_byte_length = NumberToSize(source->byte_length());
   if (offset > target_length || offset + source_length > target_length ||
       offset + source_length < offset) {  // overflow
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewRangeError(MessageTemplate::kTypedArraySetSourceTooLarge));
   }
 
-  size_t target_offset = NumberToSize(isolate, target->byte_offset());
-  size_t source_offset = NumberToSize(isolate, source->byte_offset());
+  size_t target_offset = NumberToSize(target->byte_offset());
+  size_t source_offset = NumberToSize(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;
 
   // Typed arrays of the same type: use memmove.
   if (target->type() == source->type()) {
     memmove(target_base + offset * target->element_size(), source_base,
@@ skipping 93 matching lines @@
   }
 }
 
 
 template <typename T>
 inline static bool DataViewGetValue(Isolate* isolate,
                                     Handle<JSDataView> data_view,
                                     Handle<Object> byte_offset_obj,
                                     bool is_little_endian, T* result) {
   size_t byte_offset = 0;
-  if (!TryNumberToSize(isolate, *byte_offset_obj, &byte_offset)) {
+  if (!TryNumberToSize(*byte_offset_obj, &byte_offset)) {
     return false;
   }
   Handle<JSArrayBuffer> buffer(JSArrayBuffer::cast(data_view->buffer()));
 
-  size_t data_view_byte_offset =
-      NumberToSize(isolate, data_view->byte_offset());
-  size_t data_view_byte_length =
-      NumberToSize(isolate, data_view->byte_length());
+  size_t data_view_byte_offset = NumberToSize(data_view->byte_offset());
+  size_t data_view_byte_length = NumberToSize(data_view->byte_length());
   if (byte_offset + sizeof(T) > data_view_byte_length ||
       byte_offset + sizeof(T) < byte_offset) {  // overflow
     return false;
   }
 
   union Value {
     T data;
     uint8_t bytes[sizeof(T)];
   };
 
   Value value;
   size_t buffer_offset = data_view_byte_offset + byte_offset;
-  DCHECK(NumberToSize(isolate, buffer->byte_length()) >=
-         buffer_offset + sizeof(T));
+  DCHECK(NumberToSize(buffer->byte_length()) >= buffer_offset + sizeof(T));
   uint8_t* source =
       static_cast<uint8_t*>(buffer->backing_store()) + buffer_offset;
   if (NeedToFlipBytes(is_little_endian)) {
     FlipBytes<sizeof(T)>(value.bytes, source);
   } else {
     CopyBytes<sizeof(T)>(value.bytes, source);
   }
   *result = value.data;
   return true;
 }
 
 
 template <typename T>
 static bool DataViewSetValue(Isolate* isolate, Handle<JSDataView> data_view,
                              Handle<Object> byte_offset_obj,
                              bool is_little_endian, T data) {
   size_t byte_offset = 0;
-  if (!TryNumberToSize(isolate, *byte_offset_obj, &byte_offset)) {
+  if (!TryNumberToSize(*byte_offset_obj, &byte_offset)) {
     return false;
   }
   Handle<JSArrayBuffer> buffer(JSArrayBuffer::cast(data_view->buffer()));
 
-  size_t data_view_byte_offset =
-      NumberToSize(isolate, data_view->byte_offset());
-  size_t data_view_byte_length =
-      NumberToSize(isolate, data_view->byte_length());
+  size_t data_view_byte_offset = NumberToSize(data_view->byte_offset());
+  size_t data_view_byte_length = NumberToSize(data_view->byte_length());
   if (byte_offset + sizeof(T) > data_view_byte_length ||
       byte_offset + sizeof(T) < byte_offset) {  // overflow
     return false;
   }
 
   union Value {
     T data;
     uint8_t bytes[sizeof(T)];
   };
 
   Value value;
   value.data = data;
   size_t buffer_offset = data_view_byte_offset + byte_offset;
-  DCHECK(NumberToSize(isolate, buffer->byte_length()) >=
-         buffer_offset + sizeof(T));
+  DCHECK(NumberToSize(buffer->byte_length()) >= buffer_offset + sizeof(T));
   uint8_t* target =
       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;
 }
 
@@ skipping 103 matching lines @@
 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 internal
 }  // namespace v8