Disallow sequences with lengths exceeding max allocation supported.

third_party/WebKit/Source/wtf/allocator/PartitionAllocator.h

 // Copyright (c) 2013 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.
 
 #ifndef WTF_PartitionAllocator_h
 #define WTF_PartitionAllocator_h
 
 // This is the allocator that is used for allocations that are not on the
 // traced, garbage collected heap. It uses FastMalloc for collections,
 // but uses the partition allocator for the backing store of the collections.
 
 #include "base/allocator/partition_allocator/partition_alloc.h"
 #include "third_party/WebKit/Source/wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/TypeTraits.h"
 #include "wtf/WTFExport.h"
 #include <string.h>
 
 namespace WTF {
 
 class PartitionAllocatorDummyVisitor {
   DISALLOW_NEW();
 };
 
 class WTF_EXPORT PartitionAllocator {
  public:
   typedef PartitionAllocatorDummyVisitor Visitor;
   static const bool isGarbageCollected = false;
 
+  template<typename T>
+  static size_t maxElementCountInBackingStore() {
+    return base::kGenericMaxDirectMapped / sizeof(T);
+  }
+
   template <typename T>
   static size_t quantizedSize(size_t count) {
-    RELEASE_ASSERT(count <= base::kGenericMaxDirectMapped / sizeof(T));
+    CHECK(count <= maxElementCountInBackingStore<T>());

[Yuta Kitamura, 2017/01/30 07:19:42]

nit+optional: Use CHECK_LE?

[sof, 2017/01/31 21:01:43]

Done.

     return PartitionAllocActualSize(WTF::Partitions::bufferPartition(),
                                     count * sizeof(T));
   }
   template <typename T>
   static T* allocateVectorBacking(size_t size) {
     return reinterpret_cast<T*>(
         allocateBacking(size, WTF_HEAP_PROFILER_TYPE_NAME(T)));
   }
   template <typename T>
   static T* allocateExpandedVectorBacking(size_t size) {
@@ skipping 87 matching lines @@
   void* operator new(size_t, NotNullTag, void* location) {        \
     DCHECK(location);                                             \
     return location;                                              \
   }                                                               \
   void* operator new(size_t, void* location) { return location; } \
                                                                   \
  private:                                                         \
   typedef int __thisIsHereToForceASemicolonAfterThisMacro
 
 #endif  // WTF_PartitionAllocator_h