diff --git a/dawn.json b/dawn.json
index 07bbb57..daa4872 100644
--- a/dawn.json
+++ b/dawn.json
@@ -32,8 +32,8 @@
         "members": [
             {"name": "binding", "type": "uint32_t"},
             {"name": "buffer", "type": "buffer", "optional": true},
-            {"name": "offset", "type": "uint32_t"},
-            {"name": "size", "type": "uint32_t"},
+            {"name": "offset", "type": "uint64_t"},
+            {"name": "size", "type": "uint64_t"},
             {"name": "sampler", "type": "sampler", "optional": true},
             {"name": "texture view", "type": "texture view", "optional": true}
         ]
@@ -142,8 +142,8 @@
             {
                 "name": "set sub data",
                 "args": [
-                    {"name": "start", "type": "uint32_t"},
-                    {"name": "count", "type": "uint32_t"},
+                    {"name": "start", "type": "uint64_t"},
+                    {"name": "count", "type": "uint64_t"},
                     {"name": "data", "type": "uint8_t", "annotation": "const*", "length": "count"}
                 ]
             },
@@ -174,7 +174,7 @@
         "extensible": true,
         "members": [
             {"name": "buffer", "type": "buffer"},
-            {"name": "offset", "type": "uint32_t"},
+            {"name": "offset", "type": "uint64_t"},
             {"name": "row pitch", "type": "uint32_t"},
             {"name": "image height", "type": "uint32_t"}
         ]
@@ -184,7 +184,7 @@
         "extensible": true,
         "members": [
             {"name": "usage", "type": "buffer usage bit"},
-            {"name": "size", "type": "uint32_t"}
+            {"name": "size", "type": "uint64_t"}
         ]
     },
     "buffer map read callback": {
@@ -267,10 +267,10 @@
                 "name": "copy buffer to buffer",
                 "args": [
                     {"name": "source", "type": "buffer"},
-                    {"name": "source offset", "type": "uint32_t"},
+                    {"name": "source offset", "type": "uint64_t"},
                     {"name": "destination", "type": "buffer"},
-                    {"name": "destination offset", "type": "uint32_t"},
-                    {"name": "size", "type": "uint32_t"}
+                    {"name": "destination offset", "type": "uint64_t"},
+                    {"name": "size", "type": "uint64_t"}
                 ],
                 "TODO": [
                     "Restrictions on the alignment of the copy? Cf Metal on OSX"
@@ -359,7 +359,7 @@
                     {"name": "group index", "type": "uint32_t"},
                     {"name": "group", "type": "bind group"},
                     {"name": "dynamic offset count", "type": "uint32_t"},
-                    {"name": "dynamic offsets", "type": "uint32_t", "annotation": "const*", "length": "dynamic offset count"}
+                    {"name": "dynamic offsets", "type": "uint64_t", "annotation": "const*", "length": "dynamic offset count"}
                 ]
             },
             {
@@ -573,7 +573,7 @@
         "members": [
             {"name": "shader location", "type": "uint32_t"},
             {"name": "input slot", "type": "uint32_t"},
-            {"name": "offset", "type": "uint32_t"},
+            {"name": "offset", "type": "uint64_t"},
             {"name": "format", "type": "vertex format"}
         ]
     },
@@ -582,7 +582,7 @@
         "extensible": false,
         "members": [
             {"name": "input slot", "type": "uint32_t"},
-            {"name": "stride", "type": "uint32_t"},
+            {"name": "stride", "type": "uint64_t"},
             {"name": "step mode", "type": "input step mode"}
         ]
     },
@@ -741,7 +741,7 @@
                     {"name": "group index", "type": "uint32_t"},
                     {"name": "group", "type": "bind group"},
                     {"name": "dynamic offset count", "type": "uint32_t"},
-                    {"name": "dynamic offsets", "type": "uint32_t", "annotation": "const*", "length": "dynamic offset count"}
+                    {"name": "dynamic offsets", "type": "uint64_t", "annotation": "const*", "length": "dynamic offset count"}
                 ]
             },
             {
@@ -806,14 +806,14 @@
                     {"name": "start slot", "type": "uint32_t"},
                     {"name": "count", "type": "uint32_t"},
                     {"name": "buffers", "type": "buffer", "annotation": "const*", "length": "count"},
-                    {"name": "offsets", "type": "uint32_t", "annotation": "const*", "length": "count"}
+                    {"name": "offsets", "type": "uint64_t", "annotation": "const*", "length": "count"}
                 ]
             },
             {
                 "name": "set index buffer",
                 "args": [
                     {"name": "buffer", "type": "buffer"},
-                    {"name": "offset", "type": "uint32_t"}
+                    {"name": "offset", "type": "uint64_t"}
                 ]
             },
             {
diff --git a/dawn_wire.json b/dawn_wire.json
index debad79..f2c1dce 100644
--- a/dawn_wire.json
+++ b/dawn_wire.json
@@ -35,14 +35,14 @@
             { "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
             { "name": "request serial", "type": "uint32_t" },
             { "name": "status", "type": "uint32_t" },
-            { "name": "data length", "type": "uint32_t" },
+            { "name": "data length", "type": "uint64_t" },
             { "name": "data", "type": "uint8_t", "annotation": "const*", "length": "data length" }
         ],
         "buffer map write async callback": [
             { "name": "buffer", "type": "ObjectHandle", "handle_type": "buffer" },
             { "name": "request serial", "type": "uint32_t" },
             { "name": "status", "type": "uint32_t" },
-            { "name": "data length", "type": "uint32_t" }
+            { "name": "data length", "type": "uint64_t" }
         ],
         "device error callback": [
             { "name": "message", "type": "char", "annotation": "const*", "length": "strlen" }
diff --git a/examples/ComputeBoids.cpp b/examples/ComputeBoids.cpp
index 18676d6..9a7e479 100644
--- a/examples/ComputeBoids.cpp
+++ b/examples/ComputeBoids.cpp
@@ -256,7 +256,7 @@
 }
 
 dawn::CommandBuffer createCommandBuffer(const dawn::Texture backbuffer, size_t i) {
-    static const uint32_t zeroOffsets[1] = {0};
+    static const uint64_t zeroOffsets[1] = {0};
     auto& bufferDst = particleBuffers[(i + 1) % 2];
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
 
diff --git a/examples/CppHelloTriangle.cpp b/examples/CppHelloTriangle.cpp
index 1c703af..f13d0ba 100644
--- a/examples/CppHelloTriangle.cpp
+++ b/examples/CppHelloTriangle.cpp
@@ -153,7 +153,7 @@
     utils::ComboRenderPassDescriptor renderPass({backbuffer.CreateDefaultTextureView()},
                                                 depthStencilView);
 
-    static const uint32_t vertexBufferOffsets[1] = {0};
+    static const uint64_t vertexBufferOffsets[1] = {0};
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass);
diff --git a/examples/CubeReflection.cpp b/examples/CubeReflection.cpp
index df8a191..7e6119b 100644
--- a/examples/CubeReflection.cpp
+++ b/examples/CubeReflection.cpp
@@ -249,7 +249,7 @@
     s.a = (s.a + 1) % 256;
     s.b += 0.01f;
     if (s.b >= 1.0f) {s.b = 0.0f;}
-    static const uint32_t vertexBufferOffsets[1] = {0};
+    static const uint64_t vertexBufferOffsets[1] = {0};
 
     cameraData.view = glm::lookAt(
         glm::vec3(8.f * std::sin(glm::radians(s.b * 360.f)), 2.f, 8.f * std::cos(glm::radians(s.b * 360.f))),
diff --git a/examples/glTFViewer/glTFViewer.cpp b/examples/glTFViewer/glTFViewer.cpp
index 0ec656c..af7350f 100644
--- a/examples/glTFViewer/glTFViewer.cpp
+++ b/examples/glTFViewer/glTFViewer.cpp
@@ -523,7 +523,7 @@
                 uint32_t slot = s.first;
                 auto it = iPrim.attributes.find(s.second);
                 if (it == iPrim.attributes.end()) {
-                    uint32_t zero = 0;
+                    uint64_t zero = 0;
                     pass.SetVertexBuffers(slot, 1, &defaultBuffer, &zero);
                     continue;
                 }
@@ -538,7 +538,7 @@
                     vertexCount = static_cast<uint32_t>(iAccessor.count);
                 }
                 const auto& oBuffer = buffers.at(iAccessor.bufferView);
-                uint32_t iBufferOffset = static_cast<uint32_t>(iAccessor.byteOffset);
+                uint64_t iBufferOffset = static_cast<uint64_t>(iAccessor.byteOffset);
                 pass.SetVertexBuffers(slot, 1, &oBuffer, &iBufferOffset);
             }
 
diff --git a/generator/templates/api.h b/generator/templates/api.h
index 73bf810..5d262cc 100644
--- a/generator/templates/api.h
+++ b/generator/templates/api.h
@@ -50,8 +50,8 @@
 // Custom types depending on the target language
 typedef uint64_t DawnCallbackUserdata;
 typedef void (*DawnDeviceErrorCallback)(const char* message, DawnCallbackUserdata userdata);
-typedef void (*DawnBufferMapReadCallback)(DawnBufferMapAsyncStatus status, const void* data, uint32_t dataLength, DawnCallbackUserdata userdata);
-typedef void (*DawnBufferMapWriteCallback)(DawnBufferMapAsyncStatus status, void* data, uint32_t dataLength, DawnCallbackUserdata userdata);
+typedef void (*DawnBufferMapReadCallback)(DawnBufferMapAsyncStatus status, const void* data, uint64_t dataLength, DawnCallbackUserdata userdata);
+typedef void (*DawnBufferMapWriteCallback)(DawnBufferMapAsyncStatus status, void* data, uint64_t dataLength, DawnCallbackUserdata userdata);
 typedef void (*DawnFenceOnCompletionCallback)(DawnFenceCompletionStatus status,
                                               DawnCallbackUserdata userdata);
 
diff --git a/src/dawn_native/BindGroup.cpp b/src/dawn_native/BindGroup.cpp
index f952c19..b776c91 100644
--- a/src/dawn_native/BindGroup.cpp
+++ b/src/dawn_native/BindGroup.cpp
@@ -37,7 +37,7 @@
             }
             DAWN_TRY(device->ValidateObject(binding.buffer));
 
-            uint32_t bufferSize = binding.buffer->GetSize();
+            uint64_t bufferSize = binding.buffer->GetSize();
             if (binding.size > bufferSize) {
                 return DAWN_VALIDATION_ERROR("Buffer binding size larger than the buffer");
             }
diff --git a/src/dawn_native/BindGroup.h b/src/dawn_native/BindGroup.h
index 32988ea..d31fff4 100644
--- a/src/dawn_native/BindGroup.h
+++ b/src/dawn_native/BindGroup.h
@@ -34,8 +34,8 @@
 
     struct BufferBinding {
         BufferBase* buffer;
-        uint32_t offset;
-        uint32_t size;
+        uint64_t offset;
+        uint64_t size;
     };
 
     class BindGroupBase : public ObjectBase {
diff --git a/src/dawn_native/Buffer.h b/src/dawn_native/Buffer.h
index dbe6fe5..46fe1fa 100644
--- a/src/dawn_native/Buffer.h
+++ b/src/dawn_native/Buffer.h
@@ -84,7 +84,7 @@
         MaybeError ValidateUnmap() const;
         MaybeError ValidateDestroy() const;
 
-        uint32_t mSize = 0;
+        uint64_t mSize = 0;
         dawn::BufferUsageBit mUsage = dawn::BufferUsageBit::None;
 
         DawnBufferMapReadCallback mMapReadCallback = nullptr;
diff --git a/src/dawn_native/CommandEncoder.cpp b/src/dawn_native/CommandEncoder.cpp
index 21b9992..080990a 100644
--- a/src/dawn_native/CommandEncoder.cpp
+++ b/src/dawn_native/CommandEncoder.cpp
@@ -62,12 +62,12 @@
             return {};
         }
 
-        bool FitsInBuffer(const BufferBase* buffer, uint32_t offset, uint32_t size) {
-            uint32_t bufferSize = buffer->GetSize();
+        bool FitsInBuffer(const BufferBase* buffer, uint64_t offset, uint64_t size) {
+            uint64_t bufferSize = buffer->GetSize();
             return offset <= bufferSize && (size <= (bufferSize - offset));
         }
 
-        MaybeError ValidateCopySizeFitsInBuffer(const BufferCopy& bufferCopy, uint32_t dataSize) {
+        MaybeError ValidateCopySizeFitsInBuffer(const BufferCopy& bufferCopy, uint64_t dataSize) {
             if (!FitsInBuffer(bufferCopy.buffer.Get(), bufferCopy.offset, dataSize)) {
                 return DAWN_VALIDATION_ERROR("Copy would overflow the buffer");
             }
@@ -75,9 +75,9 @@
             return {};
         }
 
-        MaybeError ValidateB2BCopySizeAlignment(uint32_t dataSize,
-                                                uint32_t srcOffset,
-                                                uint32_t dstOffset) {
+        MaybeError ValidateB2BCopySizeAlignment(uint64_t dataSize,
+                                                uint64_t srcOffset,
+                                                uint64_t dstOffset) {
             // Copy size must be a multiple of 4 bytes on macOS.
             if (dataSize % 4 != 0) {
                 return DAWN_VALIDATION_ERROR("Copy size must be a multiple of 4 bytes");
@@ -677,10 +677,10 @@
     }
 
     void CommandEncoderBase::CopyBufferToBuffer(BufferBase* source,
-                                                uint32_t sourceOffset,
+                                                uint64_t sourceOffset,
                                                 BufferBase* destination,
-                                                uint32_t destinationOffset,
-                                                uint32_t size) {
+                                                uint64_t destinationOffset,
+                                                uint64_t size) {
         if (ConsumedError(ValidateCanRecordTopLevelCommands())) {
             return;
         }
@@ -1165,7 +1165,7 @@
                 case Command::SetVertexBuffers: {
                     SetVertexBuffersCmd* cmd = mIterator.NextCommand<SetVertexBuffersCmd>();
                     auto buffers = mIterator.NextData<Ref<BufferBase>>(cmd->count);
-                    mIterator.NextData<uint32_t>(cmd->count);
+                    mIterator.NextData<uint64_t>(cmd->count);
 
                     for (uint32_t i = 0; i < cmd->count; ++i) {
                         usageTracker.BufferUsedAs(buffers[i].Get(), dawn::BufferUsageBit::Vertex);
diff --git a/src/dawn_native/CommandEncoder.h b/src/dawn_native/CommandEncoder.h
index 7ada438..a5e3c9b 100644
--- a/src/dawn_native/CommandEncoder.h
+++ b/src/dawn_native/CommandEncoder.h
@@ -40,10 +40,10 @@
         ComputePassEncoderBase* BeginComputePass();
         RenderPassEncoderBase* BeginRenderPass(const RenderPassDescriptor* info);
         void CopyBufferToBuffer(BufferBase* source,
-                                uint32_t sourceOffset,
+                                uint64_t sourceOffset,
                                 BufferBase* destination,
-                                uint32_t destinationOffset,
-                                uint32_t size);
+                                uint64_t destinationOffset,
+                                uint64_t size);
         void CopyBufferToTexture(const BufferCopyView* source,
                                  const TextureCopyView* destination,
                                  const Extent3D* copySize);
diff --git a/src/dawn_native/Commands.cpp b/src/dawn_native/Commands.cpp
index 2524d2c..1bae002 100644
--- a/src/dawn_native/Commands.cpp
+++ b/src/dawn_native/Commands.cpp
@@ -127,7 +127,7 @@
                     for (size_t i = 0; i < cmd->count; ++i) {
                         (&buffers[i])->~Ref<BufferBase>();
                     }
-                    commands->NextData<uint32_t>(cmd->count);
+                    commands->NextData<uint64_t>(cmd->count);
                     cmd->~SetVertexBuffersCmd();
                 } break;
             }
@@ -231,7 +231,7 @@
             case Command::SetVertexBuffers: {
                 auto* cmd = commands->NextCommand<SetVertexBuffersCmd>();
                 commands->NextData<Ref<BufferBase>>(cmd->count);
-                commands->NextData<uint32_t>(cmd->count);
+                commands->NextData<uint64_t>(cmd->count);
             } break;
         }
     }
diff --git a/src/dawn_native/Commands.h b/src/dawn_native/Commands.h
index f8950ee..091547c 100644
--- a/src/dawn_native/Commands.h
+++ b/src/dawn_native/Commands.h
@@ -90,7 +90,7 @@
 
     struct BufferCopy {
         Ref<BufferBase> buffer;
-        uint32_t offset;       // Bytes
+        uint64_t offset;       // Bytes
         uint32_t rowPitch;     // Bytes
         uint32_t imageHeight;  // Texels
     };
@@ -105,7 +105,7 @@
     struct CopyBufferToBufferCmd {
         BufferCopy source;
         BufferCopy destination;
-        uint32_t size;
+        uint64_t size;
     };
 
     struct CopyBufferToTextureCmd {
@@ -194,7 +194,7 @@
 
     struct SetIndexBufferCmd {
         Ref<BufferBase> buffer;
-        uint32_t offset;
+        uint64_t offset;
     };
 
     struct SetVertexBuffersCmd {
diff --git a/src/dawn_native/Device.h b/src/dawn_native/Device.h
index 0ff11d0..2561073 100644
--- a/src/dawn_native/Device.h
+++ b/src/dawn_native/Device.h
@@ -108,10 +108,10 @@
         virtual ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(
             size_t size) = 0;
         virtual MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                                   uint32_t sourceOffset,
+                                                   uint64_t sourceOffset,
                                                    BufferBase* destination,
-                                                   uint32_t destinationOffset,
-                                                   uint32_t size) = 0;
+                                                   uint64_t destinationOffset,
+                                                   uint64_t size) = 0;
 
         ResultOrError<DynamicUploader*> GetDynamicUploader() const;
 
diff --git a/src/dawn_native/ProgrammablePassEncoder.cpp b/src/dawn_native/ProgrammablePassEncoder.cpp
index fb8067a..3c2b53a 100644
--- a/src/dawn_native/ProgrammablePassEncoder.cpp
+++ b/src/dawn_native/ProgrammablePassEncoder.cpp
@@ -85,7 +85,7 @@
     void ProgrammablePassEncoder::SetBindGroup(uint32_t groupIndex,
                                                BindGroupBase* group,
                                                uint32_t dynamicOffsetCount,
-                                               const uint32_t* dynamicOffsets) {
+                                               const uint64_t* dynamicOffsets) {
         if (mTopLevelEncoder->ConsumedError(ValidateCanRecordCommands()) ||
             mTopLevelEncoder->ConsumedError(GetDevice()->ValidateObject(group))) {
             return;
diff --git a/src/dawn_native/ProgrammablePassEncoder.h b/src/dawn_native/ProgrammablePassEncoder.h
index a2dd046..d37f9be 100644
--- a/src/dawn_native/ProgrammablePassEncoder.h
+++ b/src/dawn_native/ProgrammablePassEncoder.h
@@ -42,7 +42,7 @@
         void SetBindGroup(uint32_t groupIndex,
                           BindGroupBase* group,
                           uint32_t dynamicOffsetCount,
-                          const uint32_t* dynamicOffsets);
+                          const uint64_t* dynamicOffsets);
         void SetPushConstants(dawn::ShaderStageBit stages,
                               uint32_t offset,
                               uint32_t count,
diff --git a/src/dawn_native/RenderPassEncoder.cpp b/src/dawn_native/RenderPassEncoder.cpp
index 23f923d..9288c6a 100644
--- a/src/dawn_native/RenderPassEncoder.cpp
+++ b/src/dawn_native/RenderPassEncoder.cpp
@@ -128,7 +128,7 @@
         cmd->height = height;
     }
 
-    void RenderPassEncoderBase::SetIndexBuffer(BufferBase* buffer, uint32_t offset) {
+    void RenderPassEncoderBase::SetIndexBuffer(BufferBase* buffer, uint64_t offset) {
         if (mTopLevelEncoder->ConsumedError(ValidateCanRecordCommands()) ||
             mTopLevelEncoder->ConsumedError(GetDevice()->ValidateObject(buffer))) {
             return;
@@ -143,7 +143,7 @@
     void RenderPassEncoderBase::SetVertexBuffers(uint32_t startSlot,
                                                  uint32_t count,
                                                  BufferBase* const* buffers,
-                                                 uint32_t const* offsets) {
+                                                 uint64_t const* offsets) {
         if (mTopLevelEncoder->ConsumedError(ValidateCanRecordCommands())) {
             return;
         }
@@ -165,8 +165,8 @@
             new (&cmdBuffers[i]) Ref<BufferBase>(buffers[i]);
         }
 
-        uint32_t* cmdOffsets = mAllocator->AllocateData<uint32_t>(count);
-        memcpy(cmdOffsets, offsets, count * sizeof(uint32_t));
+        uint64_t* cmdOffsets = mAllocator->AllocateData<uint64_t>(count);
+        memcpy(cmdOffsets, offsets, count * sizeof(uint64_t));
     }
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/RenderPassEncoder.h b/src/dawn_native/RenderPassEncoder.h
index 408cbe7..ccc776f 100644
--- a/src/dawn_native/RenderPassEncoder.h
+++ b/src/dawn_native/RenderPassEncoder.h
@@ -53,7 +53,7 @@
         void SetVertexBuffers(uint32_t startSlot,
                               uint32_t count,
                               T* const* buffers,
-                              uint32_t const* offsets) {
+                              uint64_t const* offsets) {
             static_assert(std::is_base_of<BufferBase, T>::value, "");
             SetVertexBuffers(startSlot, count, reinterpret_cast<BufferBase* const*>(buffers),
                              offsets);
@@ -61,8 +61,8 @@
         void SetVertexBuffers(uint32_t startSlot,
                               uint32_t count,
                               BufferBase* const* buffers,
-                              uint32_t const* offsets);
-        void SetIndexBuffer(BufferBase* buffer, uint32_t offset);
+                              uint64_t const* offsets);
+        void SetIndexBuffer(BufferBase* buffer, uint64_t offset);
 
       protected:
         RenderPassEncoderBase(DeviceBase* device,
diff --git a/src/dawn_native/d3d12/CommandBufferD3D12.cpp b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
index 25437cd..b0603a2 100644
--- a/src/dawn_native/d3d12/CommandBufferD3D12.cpp
+++ b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
@@ -861,7 +861,7 @@
                 case Command::SetVertexBuffers: {
                     SetVertexBuffersCmd* cmd = mCommands.NextCommand<SetVertexBuffersCmd>();
                     auto buffers = mCommands.NextData<Ref<BufferBase>>(cmd->count);
-                    auto offsets = mCommands.NextData<uint32_t>(cmd->count);
+                    auto offsets = mCommands.NextData<uint64_t>(cmd->count);
 
                     vertexBuffersInfo.startSlot =
                         std::min(vertexBuffersInfo.startSlot, cmd->startSlot);
diff --git a/src/dawn_native/d3d12/DeviceD3D12.cpp b/src/dawn_native/d3d12/DeviceD3D12.cpp
index 33c4efd..bd30f25 100644
--- a/src/dawn_native/d3d12/DeviceD3D12.cpp
+++ b/src/dawn_native/d3d12/DeviceD3D12.cpp
@@ -253,10 +253,10 @@
     }
 
     MaybeError Device::CopyFromStagingToBuffer(StagingBufferBase* source,
-                                               uint32_t sourceOffset,
+                                               uint64_t sourceOffset,
                                                BufferBase* destination,
-                                               uint32_t destinationOffset,
-                                               uint32_t size) {
+                                               uint64_t destinationOffset,
+                                               uint64_t size) {
         ToBackend(destination)
             ->TransitionUsageNow(GetPendingCommandList(), dawn::BufferUsageBit::TransferDst);
 
diff --git a/src/dawn_native/d3d12/DeviceD3D12.h b/src/dawn_native/d3d12/DeviceD3D12.h
index c76ec92..a73ca6b 100644
--- a/src/dawn_native/d3d12/DeviceD3D12.h
+++ b/src/dawn_native/d3d12/DeviceD3D12.h
@@ -69,10 +69,10 @@
 
         ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(size_t size) override;
         MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                           uint32_t sourceOffset,
+                                           uint64_t sourceOffset,
                                            BufferBase* destination,
-                                           uint32_t destinationOffset,
-                                           uint32_t size) override;
+                                           uint64_t destinationOffset,
+                                           uint64_t size) override;
 
       private:
         ResultOrError<BindGroupBase*> CreateBindGroupImpl(
diff --git a/src/dawn_native/d3d12/TextureCopySplitter.cpp b/src/dawn_native/d3d12/TextureCopySplitter.cpp
index 5e58cbc..201c463 100644
--- a/src/dawn_native/d3d12/TextureCopySplitter.cpp
+++ b/src/dawn_native/d3d12/TextureCopySplitter.cpp
@@ -39,14 +39,15 @@
     TextureCopySplit ComputeTextureCopySplit(Origin3D origin,
                                              Extent3D copySize,
                                              uint32_t texelSize,
-                                             uint32_t offset,
+                                             uint64_t offset,
                                              uint32_t rowPitch,
                                              uint32_t imageHeight) {
         TextureCopySplit copy;
 
         ASSERT(rowPitch % texelSize == 0);
 
-        uint32_t alignedOffset = offset & ~(D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT - 1);
+        uint64_t alignedOffset =
+            offset & ~static_cast<uint64_t>(D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT - 1);
 
         copy.offset = alignedOffset;
         if (offset == alignedOffset) {
@@ -67,10 +68,11 @@
         }
 
         ASSERT(alignedOffset < offset);
+        ASSERT(offset - alignedOffset < D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT);
 
         Origin3D texelOffset;
-        ComputeTexelOffsets(offset - alignedOffset, rowPitch, rowPitch * imageHeight, texelSize,
-                            &texelOffset);
+        ComputeTexelOffsets(static_cast<uint32_t>(offset - alignedOffset), rowPitch,
+                            rowPitch * imageHeight, texelSize, &texelOffset);
 
         uint32_t rowPitchInTexels = rowPitch / texelSize;
 
diff --git a/src/dawn_native/d3d12/TextureCopySplitter.h b/src/dawn_native/d3d12/TextureCopySplitter.h
index e468fc6..e70a0e1 100644
--- a/src/dawn_native/d3d12/TextureCopySplitter.h
+++ b/src/dawn_native/d3d12/TextureCopySplitter.h
@@ -32,7 +32,7 @@
             Extent3D copySize;
         };
 
-        uint32_t offset = 0;
+        uint64_t offset = 0;
         uint32_t count = 0;
         std::array<CopyInfo, kMaxTextureCopyRegions> copies;
     };
@@ -40,7 +40,7 @@
     TextureCopySplit ComputeTextureCopySplit(Origin3D origin,
                                              Extent3D copySize,
                                              uint32_t texelSize,
-                                             uint32_t offset,
+                                             uint64_t offset,
                                              uint32_t rowPitch,
                                              uint32_t imageHeight);
 }}  // namespace dawn_native::d3d12
diff --git a/src/dawn_native/metal/CommandBufferMTL.mm b/src/dawn_native/metal/CommandBufferMTL.mm
index 8047383..05ef455 100644
--- a/src/dawn_native/metal/CommandBufferMTL.mm
+++ b/src/dawn_native/metal/CommandBufferMTL.mm
@@ -307,7 +307,7 @@
                         break;
                     }
 
-                    uint32_t offset = src.offset;
+                    uint64_t offset = src.offset;
 
                     // Doing all the copy except the last image.
                     if (size.depth > 1) {
@@ -419,7 +419,7 @@
                         break;
                     }
 
-                    uint32_t offset = dst.offset;
+                    uint64_t offset = dst.offset;
 
                     // Doing all the copy except the last image.
                     if (size.depth > 1) {
@@ -743,7 +743,7 @@
                 case Command::SetVertexBuffers: {
                     SetVertexBuffersCmd* cmd = mCommands.NextCommand<SetVertexBuffersCmd>();
                     auto buffers = mCommands.NextData<Ref<BufferBase>>(cmd->count);
-                    auto offsets = mCommands.NextData<uint32_t>(cmd->count);
+                    auto offsets = mCommands.NextData<uint64_t>(cmd->count);
 
                     std::array<id<MTLBuffer>, kMaxVertexInputs> mtlBuffers;
                     std::array<NSUInteger, kMaxVertexInputs> mtlOffsets;
diff --git a/src/dawn_native/metal/DeviceMTL.h b/src/dawn_native/metal/DeviceMTL.h
index 59fc9aa..87eec00 100644
--- a/src/dawn_native/metal/DeviceMTL.h
+++ b/src/dawn_native/metal/DeviceMTL.h
@@ -58,10 +58,10 @@
 
         ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(size_t size) override;
         MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                           uint32_t sourceOffset,
+                                           uint64_t sourceOffset,
                                            BufferBase* destination,
-                                           uint32_t destinationOffset,
-                                           uint32_t size) override;
+                                           uint64_t destinationOffset,
+                                           uint64_t size) override;
 
       private:
         ResultOrError<BindGroupBase*> CreateBindGroupImpl(
diff --git a/src/dawn_native/metal/DeviceMTL.mm b/src/dawn_native/metal/DeviceMTL.mm
index 322a9ba..c53e662 100644
--- a/src/dawn_native/metal/DeviceMTL.mm
+++ b/src/dawn_native/metal/DeviceMTL.mm
@@ -215,10 +215,10 @@
     }
 
     MaybeError Device::CopyFromStagingToBuffer(StagingBufferBase* source,
-                                               uint32_t sourceOffset,
+                                               uint64_t sourceOffset,
                                                BufferBase* destination,
-                                               uint32_t destinationOffset,
-                                               uint32_t size) {
+                                               uint64_t destinationOffset,
+                                               uint64_t size) {
         id<MTLBuffer> uploadBuffer = ToBackend(source)->GetBufferHandle();
         id<MTLBuffer> buffer = ToBackend(destination)->GetMTLBuffer();
         id<MTLCommandBuffer> commandBuffer = GetPendingCommandBuffer();
diff --git a/src/dawn_native/null/DeviceNull.cpp b/src/dawn_native/null/DeviceNull.cpp
index 0482f2e..30e501c 100644
--- a/src/dawn_native/null/DeviceNull.cpp
+++ b/src/dawn_native/null/DeviceNull.cpp
@@ -125,10 +125,10 @@
     }
 
     MaybeError Device::CopyFromStagingToBuffer(StagingBufferBase* source,
-                                               uint32_t sourceOffset,
+                                               uint64_t sourceOffset,
                                                BufferBase* destination,
-                                               uint32_t destinationOffset,
-                                               uint32_t size) {
+                                               uint64_t destinationOffset,
+                                               uint64_t size) {
         return DAWN_UNIMPLEMENTED_ERROR("Device unable to copy from staging buffer.");
     }
 
diff --git a/src/dawn_native/null/DeviceNull.h b/src/dawn_native/null/DeviceNull.h
index 8880658..5450b4b 100644
--- a/src/dawn_native/null/DeviceNull.h
+++ b/src/dawn_native/null/DeviceNull.h
@@ -97,10 +97,10 @@
 
         ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(size_t size) override;
         MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                           uint32_t sourceOffset,
+                                           uint64_t sourceOffset,
                                            BufferBase* destination,
-                                           uint32_t destinationOffset,
-                                           uint32_t size) override;
+                                           uint64_t destinationOffset,
+                                           uint64_t size) override;
 
       private:
         ResultOrError<BindGroupBase*> CreateBindGroupImpl(
diff --git a/src/dawn_native/opengl/CommandBufferGL.cpp b/src/dawn_native/opengl/CommandBufferGL.cpp
index 3a5080f..5b7e968 100644
--- a/src/dawn_native/opengl/CommandBufferGL.cpp
+++ b/src/dawn_native/opengl/CommandBufferGL.cpp
@@ -198,7 +198,7 @@
             void OnSetVertexBuffers(uint32_t startSlot,
                                     uint32_t count,
                                     Ref<BufferBase>* buffers,
-                                    uint32_t* offsets) {
+                                    uint64_t* offsets) {
                 for (uint32_t i = 0; i < count; ++i) {
                     uint32_t slot = startSlot + i;
                     mVertexBuffers[slot] = ToBackend(buffers[i].Get());
@@ -234,7 +234,7 @@
                         auto attribute = mLastPipeline->GetAttribute(location);
 
                         GLuint buffer = mVertexBuffers[slot]->GetHandle();
-                        uint32_t offset = mVertexBufferOffsets[slot];
+                        uint64_t offset = mVertexBufferOffsets[slot];
 
                         auto input = mLastPipeline->GetInput(slot);
                         auto components = VertexFormatNumComponents(attribute.format);
@@ -258,7 +258,7 @@
 
             std::bitset<kMaxVertexInputs> mDirtyVertexBuffers;
             std::array<Buffer*, kMaxVertexInputs> mVertexBuffers;
-            std::array<uint32_t, kMaxVertexInputs> mVertexBufferOffsets;
+            std::array<uint64_t, kMaxVertexInputs> mVertexBufferOffsets;
 
             RenderPipelineBase* mLastPipeline = nullptr;
         };
@@ -692,7 +692,7 @@
         }
 
         RenderPipeline* lastPipeline = nullptr;
-        uint32_t indexBufferBaseOffset = 0;
+        uint64_t indexBufferBaseOffset = 0;
 
         PersistentPipelineState persistentPipelineState;
 
@@ -815,7 +815,7 @@
                 case Command::SetVertexBuffers: {
                     SetVertexBuffersCmd* cmd = mCommands.NextCommand<SetVertexBuffersCmd>();
                     auto buffers = mCommands.NextData<Ref<BufferBase>>(cmd->count);
-                    auto offsets = mCommands.NextData<uint32_t>(cmd->count);
+                    auto offsets = mCommands.NextData<uint64_t>(cmd->count);
                     inputBuffers.OnSetVertexBuffers(cmd->startSlot, cmd->count, buffers, offsets);
                 } break;
 
diff --git a/src/dawn_native/opengl/DeviceGL.cpp b/src/dawn_native/opengl/DeviceGL.cpp
index 2d2b6e1..7dd761b 100644
--- a/src/dawn_native/opengl/DeviceGL.cpp
+++ b/src/dawn_native/opengl/DeviceGL.cpp
@@ -149,10 +149,10 @@
     }
 
     MaybeError Device::CopyFromStagingToBuffer(StagingBufferBase* source,
-                                               uint32_t sourceOffset,
+                                               uint64_t sourceOffset,
                                                BufferBase* destination,
-                                               uint32_t destinationOffset,
-                                               uint32_t size) {
+                                               uint64_t destinationOffset,
+                                               uint64_t size) {
         return DAWN_UNIMPLEMENTED_ERROR("Device unable to copy from staging buffer.");
     }
 
diff --git a/src/dawn_native/opengl/DeviceGL.h b/src/dawn_native/opengl/DeviceGL.h
index 5cb1262..5725a8e 100644
--- a/src/dawn_native/opengl/DeviceGL.h
+++ b/src/dawn_native/opengl/DeviceGL.h
@@ -49,10 +49,10 @@
 
         ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(size_t size) override;
         MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                           uint32_t sourceOffset,
+                                           uint64_t sourceOffset,
                                            BufferBase* destination,
-                                           uint32_t destinationOffset,
-                                           uint32_t size) override;
+                                           uint64_t destinationOffset,
+                                           uint64_t size) override;
 
       private:
         ResultOrError<BindGroupBase*> CreateBindGroupImpl(
diff --git a/src/dawn_native/vulkan/CommandBufferVk.cpp b/src/dawn_native/vulkan/CommandBufferVk.cpp
index 7bec373..e65f537 100644
--- a/src/dawn_native/vulkan/CommandBufferVk.cpp
+++ b/src/dawn_native/vulkan/CommandBufferVk.cpp
@@ -611,7 +611,7 @@
                 case Command::SetVertexBuffers: {
                     SetVertexBuffersCmd* cmd = mCommands.NextCommand<SetVertexBuffersCmd>();
                     auto buffers = mCommands.NextData<Ref<BufferBase>>(cmd->count);
-                    auto offsets = mCommands.NextData<uint32_t>(cmd->count);
+                    auto offsets = mCommands.NextData<uint64_t>(cmd->count);
 
                     std::array<VkBuffer, kMaxVertexInputs> vkBuffers;
                     std::array<VkDeviceSize, kMaxVertexInputs> vkOffsets;
diff --git a/src/dawn_native/vulkan/DeviceVk.cpp b/src/dawn_native/vulkan/DeviceVk.cpp
index f2ab5a5..212adb0 100644
--- a/src/dawn_native/vulkan/DeviceVk.cpp
+++ b/src/dawn_native/vulkan/DeviceVk.cpp
@@ -502,10 +502,10 @@
     }
 
     MaybeError Device::CopyFromStagingToBuffer(StagingBufferBase* source,
-                                               uint32_t sourceOffset,
+                                               uint64_t sourceOffset,
                                                BufferBase* destination,
-                                               uint32_t destinationOffset,
-                                               uint32_t size) {
+                                               uint64_t destinationOffset,
+                                               uint64_t size) {
         // Insert memory barrier to ensure host write operations are made visible before
         // copying from the staging buffer. However, this barrier can be removed (see note below).
         //
diff --git a/src/dawn_native/vulkan/DeviceVk.h b/src/dawn_native/vulkan/DeviceVk.h
index c59883e..699aefd 100644
--- a/src/dawn_native/vulkan/DeviceVk.h
+++ b/src/dawn_native/vulkan/DeviceVk.h
@@ -72,10 +72,11 @@
 
         ResultOrError<std::unique_ptr<StagingBufferBase>> CreateStagingBuffer(size_t size) override;
         MaybeError CopyFromStagingToBuffer(StagingBufferBase* source,
-                                           uint32_t sourceOffset,
+                                           uint64_t sourceOffset,
                                            BufferBase* destination,
-                                           uint32_t destinationOffset,
-                                           uint32_t size) override;
+                                           uint64_t destinationOffset,
+                                           uint64_t size) override;
+
       private:
         ResultOrError<BindGroupBase*> CreateBindGroupImpl(
             const BindGroupDescriptor* descriptor) override;
diff --git a/src/dawn_wire/client/Buffer.h b/src/dawn_wire/client/Buffer.h
index c1a6cf9..be830c5 100644
--- a/src/dawn_wire/client/Buffer.h
+++ b/src/dawn_wire/client/Buffer.h
@@ -44,7 +44,7 @@
         // Only one mapped pointer can be active at a time because Unmap clears all the in-flight
         // requests.
         void* mappedData = nullptr;
-        size_t mappedDataSize = 0;
+        uint64_t mappedDataSize = 0;
         bool isWriteMapped = false;
     };
 
diff --git a/src/dawn_wire/client/ClientDoers.cpp b/src/dawn_wire/client/ClientDoers.cpp
index 684b95e..191f65d 100644
--- a/src/dawn_wire/client/ClientDoers.cpp
+++ b/src/dawn_wire/client/ClientDoers.cpp
@@ -27,7 +27,7 @@
     bool Client::DoBufferMapReadAsyncCallback(Buffer* buffer,
                                               uint32_t requestSerial,
                                               uint32_t status,
-                                              uint32_t dataLength,
+                                              uint64_t dataLength,
                                               const uint8_t* data) {
         // The buffer might have been deleted or recreated so this isn't an error.
         if (buffer == nullptr) {
@@ -77,7 +77,7 @@
     bool Client::DoBufferMapWriteAsyncCallback(Buffer* buffer,
                                                uint32_t requestSerial,
                                                uint32_t status,
-                                               uint32_t dataLength) {
+                                               uint64_t dataLength) {
         // The buffer might have been deleted or recreated so this isn't an error.
         if (buffer == nullptr) {
             return true;
diff --git a/src/dawn_wire/server/Server.h b/src/dawn_wire/server/Server.h
index 2081f55..66d652d 100644
--- a/src/dawn_wire/server/Server.h
+++ b/src/dawn_wire/server/Server.h
@@ -25,7 +25,7 @@
         Server* server;
         ObjectHandle buffer;
         uint32_t requestSerial;
-        uint32_t size;
+        uint64_t size;
         bool isWrite;
     };
 
@@ -51,11 +51,11 @@
         static void ForwardDeviceError(const char* message, DawnCallbackUserdata userdata);
         static void ForwardBufferMapReadAsync(DawnBufferMapAsyncStatus status,
                                               const void* ptr,
-                                              uint32_t dataLength,
+                                              uint64_t dataLength,
                                               DawnCallbackUserdata userdata);
         static void ForwardBufferMapWriteAsync(DawnBufferMapAsyncStatus status,
                                                void* ptr,
-                                               uint32_t dataLength,
+                                               uint64_t dataLength,
                                                DawnCallbackUserdata userdata);
         static void ForwardFenceCompletedValue(DawnFenceCompletionStatus status,
                                                DawnCallbackUserdata userdata);
@@ -64,11 +64,11 @@
         void OnDeviceError(const char* message);
         void OnBufferMapReadAsyncCallback(DawnBufferMapAsyncStatus status,
                                           const void* ptr,
-                                          uint32_t dataLength,
+                                          uint64_t dataLength,
                                           MapUserdata* userdata);
         void OnBufferMapWriteAsyncCallback(DawnBufferMapAsyncStatus status,
                                            void* ptr,
-                                           uint32_t dataLength,
+                                           uint64_t dataLength,
                                            MapUserdata* userdata);
         void OnFenceCompletedValueUpdated(DawnFenceCompletionStatus status,
                                           FenceCompletionUserdata* userdata);
diff --git a/src/dawn_wire/server/ServerBuffer.cpp b/src/dawn_wire/server/ServerBuffer.cpp
index 22fd60e..7899227 100644
--- a/src/dawn_wire/server/ServerBuffer.cpp
+++ b/src/dawn_wire/server/ServerBuffer.cpp
@@ -83,7 +83,7 @@
 
     void Server::ForwardBufferMapReadAsync(DawnBufferMapAsyncStatus status,
                                            const void* ptr,
-                                           uint32_t dataLength,
+                                           uint64_t dataLength,
                                            DawnCallbackUserdata userdata) {
         auto data = reinterpret_cast<MapUserdata*>(static_cast<uintptr_t>(userdata));
         data->server->OnBufferMapReadAsyncCallback(status, ptr, dataLength, data);
@@ -91,7 +91,7 @@
 
     void Server::ForwardBufferMapWriteAsync(DawnBufferMapAsyncStatus status,
                                             void* ptr,
-                                            uint32_t dataLength,
+                                            uint64_t dataLength,
                                             DawnCallbackUserdata userdata) {
         auto data = reinterpret_cast<MapUserdata*>(static_cast<uintptr_t>(userdata));
         data->server->OnBufferMapWriteAsyncCallback(status, ptr, dataLength, data);
@@ -99,7 +99,7 @@
 
     void Server::OnBufferMapReadAsyncCallback(DawnBufferMapAsyncStatus status,
                                               const void* ptr,
-                                              uint32_t dataLength,
+                                              uint64_t dataLength,
                                               MapUserdata* userdata) {
         std::unique_ptr<MapUserdata> data(userdata);
 
@@ -127,7 +127,7 @@
 
     void Server::OnBufferMapWriteAsyncCallback(DawnBufferMapAsyncStatus status,
                                                void* ptr,
-                                               uint32_t dataLength,
+                                               uint64_t dataLength,
                                                MapUserdata* userdata) {
         std::unique_ptr<MapUserdata> data(userdata);
 
diff --git a/src/tests/DawnTest.cpp b/src/tests/DawnTest.cpp
index f77aba4..6747b38 100644
--- a/src/tests/DawnTest.cpp
+++ b/src/tests/DawnTest.cpp
@@ -345,8 +345,8 @@
 std::ostringstream& DawnTest::AddBufferExpectation(const char* file,
                                                    int line,
                                                    const dawn::Buffer& buffer,
-                                                   uint32_t offset,
-                                                   uint32_t size,
+                                                   uint64_t offset,
+                                                   uint64_t size,
                                                    detail::Expectation* expectation) {
     auto readback = ReserveReadback(size);
 
@@ -440,7 +440,7 @@
     }
 }
 
-DawnTest::ReadbackReservation DawnTest::ReserveReadback(uint32_t readbackSize) {
+DawnTest::ReadbackReservation DawnTest::ReserveReadback(uint64_t readbackSize) {
     // For now create a new MapRead buffer for each readback
     // TODO(cwallez@chromium.org): eventually make bigger buffers and allocate linearly?
     dawn::BufferDescriptor descriptor;
@@ -483,7 +483,7 @@
 // static
 void DawnTest::SlotMapReadCallback(DawnBufferMapAsyncStatus status,
                                    const void* data,
-                                   uint32_t,
+                                   uint64_t,
                                    DawnCallbackUserdata userdata_) {
     DAWN_ASSERT(status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS);
 
diff --git a/src/tests/DawnTest.h b/src/tests/DawnTest.h
index 98f8909..6b2428d 100644
--- a/src/tests/DawnTest.h
+++ b/src/tests/DawnTest.h
@@ -143,8 +143,8 @@
     std::ostringstream& AddBufferExpectation(const char* file,
                                              int line,
                                              const dawn::Buffer& buffer,
-                                             uint32_t offset,
-                                             uint32_t size,
+                                             uint64_t offset,
+                                             uint64_t size,
                                              detail::Expectation* expectation);
     std::ostringstream& AddTextureExpectation(const char* file,
                                               int line,
@@ -178,7 +178,7 @@
     // MapRead buffers used to get data for the expectations
     struct ReadbackSlot {
         dawn::Buffer buffer;
-        uint32_t bufferSize;
+        uint64_t bufferSize;
         const void* mappedData = nullptr;
     };
     std::vector<ReadbackSlot> mReadbackSlots;
@@ -187,7 +187,7 @@
     void MapSlotsSynchronously();
     static void SlotMapReadCallback(DawnBufferMapAsyncStatus status,
                                     const void* data,
-                                    uint32_t dataLength,
+                                    uint64_t dataLength,
                                     DawnCallbackUserdata userdata);
     size_t mNumPendingMapOperations = 0;
 
@@ -195,16 +195,16 @@
     struct ReadbackReservation {
         dawn::Buffer buffer;
         size_t slot;
-        uint32_t offset;
+        uint64_t offset;
     };
-    ReadbackReservation ReserveReadback(uint32_t readbackSize);
+    ReadbackReservation ReserveReadback(uint64_t readbackSize);
 
     struct DeferredExpectation {
         const char* file;
         int line;
         size_t readbackSlot;
-        uint32_t readbackOffset;
-        uint32_t size;
+        uint64_t readbackOffset;
+        uint64_t size;
         uint32_t rowBytes;
         uint32_t rowPitch;
         std::unique_ptr<detail::Expectation> expectation;
diff --git a/src/tests/end2end/BufferTests.cpp b/src/tests/end2end/BufferTests.cpp
index cc3db89..eac536c 100644
--- a/src/tests/end2end/BufferTests.cpp
+++ b/src/tests/end2end/BufferTests.cpp
@@ -20,7 +20,7 @@
     protected:
       static void MapReadCallback(DawnBufferMapAsyncStatus status,
                                   const void* data,
-                                  uint32_t,
+                                  uint64_t,
                                   DawnCallbackUserdata userdata) {
           ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
           ASSERT_NE(nullptr, data);
@@ -87,7 +87,7 @@
     protected:
       static void MapWriteCallback(DawnBufferMapAsyncStatus status,
                                    void* data,
-                                   uint32_t,
+                                   uint64_t,
                                    DawnCallbackUserdata userdata) {
           ASSERT_EQ(DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS, status);
           ASSERT_NE(nullptr, data);
@@ -171,7 +171,7 @@
     descriptor.usage = dawn::BufferUsageBit::TransferSrc | dawn::BufferUsageBit::TransferDst;
     dawn::Buffer buffer = device.CreateBuffer(&descriptor);
 
-    constexpr uint32_t kOffset = 2000;
+    constexpr uint64_t kOffset = 2000;
     uint32_t value = 0x01020304;
     buffer.SetSubData(kOffset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
 
@@ -189,7 +189,7 @@
     // executing these commands in-flight. If this takes longer than ~2s, a device reset occurs and
     // fails the test. Since GPUs may or may not complete by then, this test must be disabled OR
     // modified to be well-below the timeout limit.
-    constexpr uint32_t kSize = 4000 * 1000;
+    constexpr uint64_t kSize = 4000 * 1000;
     constexpr uint32_t kElements = 500 * 500;
     dawn::BufferDescriptor descriptor;
     descriptor.size = kSize;
@@ -207,7 +207,7 @@
 
 // Test using SetSubData for lots of data
 TEST_P(BufferSetSubDataTests, LargeSetSubData) {
-    constexpr uint32_t kSize = 4000 * 1000;
+    constexpr uint64_t kSize = 4000 * 1000;
     constexpr uint32_t kElements = 1000 * 1000;
     dawn::BufferDescriptor descriptor;
     descriptor.size = kSize;
diff --git a/src/tests/end2end/CopyTests.cpp b/src/tests/end2end/CopyTests.cpp
index 3ff2ff0..c7bf45b 100644
--- a/src/tests/end2end/CopyTests.cpp
+++ b/src/tests/end2end/CopyTests.cpp
@@ -35,8 +35,8 @@
         };
 
         struct BufferSpec {
-            uint32_t size;
-            uint32_t offset;
+            uint64_t size;
+            uint64_t offset;
             uint32_t rowPitch;
         };
 
@@ -123,7 +123,7 @@
             std::vector<RGBA8> emptyData(bufferSpec.size / kBytesPerTexel * textureSpec.arraySize);
             buffer.SetSubData(0, static_cast<uint32_t>(emptyData.size() * sizeof(RGBA8)), reinterpret_cast<const uint8_t*>(emptyData.data()));
 
-            uint32_t bufferOffset = bufferSpec.offset;
+            uint64_t bufferOffset = bufferSpec.offset;
             for (uint32_t slice = 0; slice < textureSpec.arraySize; ++slice) {
                 // Copy the region [(`x`, `y`), (`x + copyWidth, `y + copyWidth`)] from the `level` mip into the buffer at `offset + bufferSpec.size * slice` and `rowPitch`
                 dawn::TextureCopyView textureCopyView = utils::CreateTextureCopyView(
@@ -463,7 +463,7 @@
     constexpr uint32_t kHeight = 128;
     for (unsigned int i = 0; i < 3; ++i) {
         BufferSpec bufferSpec = MinimumBufferSpec(kWidth, kHeight);
-        uint32_t offset = 512 * i;
+        uint64_t offset = 512 * i;
         bufferSpec.size += offset;
         bufferSpec.offset += offset;
         DoTest({ kWidth, kHeight, 0, 0, kWidth, kHeight, 0 }, bufferSpec);
@@ -627,7 +627,7 @@
     constexpr uint32_t kHeight = 128;
     for (unsigned int i = 0; i < 3; ++i) {
         BufferSpec bufferSpec = MinimumBufferSpec(kWidth, kHeight);
-        uint32_t offset = 512 * i;
+        uint64_t offset = 512 * i;
         bufferSpec.size += offset;
         bufferSpec.offset += offset;
         DoTest({ kWidth, kHeight, 0, 0, kWidth, kHeight, 0 }, bufferSpec);
diff --git a/src/tests/end2end/DestroyTests.cpp b/src/tests/end2end/DestroyTests.cpp
index 0904820..8bd4cda 100644
--- a/src/tests/end2end/DestroyTests.cpp
+++ b/src/tests/end2end/DestroyTests.cpp
@@ -70,7 +70,7 @@
     dawn::Buffer vertexBuffer;
 
     dawn::CommandBuffer CreateTriangleCommandBuffer() {
-        uint32_t zeroOffset = 0;
+        uint64_t zeroOffset = 0;
         dawn::CommandEncoder encoder = device.CreateCommandEncoder();
         {
             dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
diff --git a/src/tests/end2end/DrawIndexedTests.cpp b/src/tests/end2end/DrawIndexedTests.cpp
index c46d8761..c1b889e 100644
--- a/src/tests/end2end/DrawIndexedTests.cpp
+++ b/src/tests/end2end/DrawIndexedTests.cpp
@@ -80,7 +80,7 @@
         void Test(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex,
                   uint32_t baseVertex, uint32_t firstInstance, RGBA8 bottomLeftExpected,
                   RGBA8 topRightExpected) {
-            uint32_t zeroOffset = 0;
+            uint64_t zeroOffset = 0;
             dawn::CommandEncoder encoder = device.CreateCommandEncoder();
             {
                 dawn::RenderPassEncoder pass = encoder.BeginRenderPass(
diff --git a/src/tests/end2end/DrawTests.cpp b/src/tests/end2end/DrawTests.cpp
index 0964267..b2c36f7 100644
--- a/src/tests/end2end/DrawTests.cpp
+++ b/src/tests/end2end/DrawTests.cpp
@@ -73,7 +73,7 @@
               uint32_t firstInstance,
               RGBA8 bottomLeftExpected,
               RGBA8 topRightExpected) {
-        uint32_t zeroOffset = 0;
+        uint64_t zeroOffset = 0;
         dawn::CommandEncoder encoder = device.CreateCommandEncoder();
         {
             dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
diff --git a/src/tests/end2end/IndexFormatTests.cpp b/src/tests/end2end/IndexFormatTests.cpp
index 084f74f..d4b2acb 100644
--- a/src/tests/end2end/IndexFormatTests.cpp
+++ b/src/tests/end2end/IndexFormatTests.cpp
@@ -78,7 +78,7 @@
         1, 2, 3
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
@@ -109,7 +109,7 @@
         1, 2, 0, 0, 0, 0
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
@@ -153,7 +153,7 @@
         0, 1, 2, 0xFFFFFFFFu, 3, 4, 2,
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
@@ -189,7 +189,7 @@
         0xFFFFu,
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
@@ -228,7 +228,7 @@
         1, 2, 3
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
@@ -263,7 +263,7 @@
         0, 1, 2
     });
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
diff --git a/src/tests/end2end/InputStateTests.cpp b/src/tests/end2end/InputStateTests.cpp
index f848601..c463dc1 100644
--- a/src/tests/end2end/InputStateTests.cpp
+++ b/src/tests/end2end/InputStateTests.cpp
@@ -134,13 +134,13 @@
 
         struct InputSpec {
             uint32_t slot;
-            uint32_t stride;
+            uint64_t stride;
             InputStepMode step;
         };
         struct AttributeSpec {
             uint32_t location;
             uint32_t slot;
-            uint32_t offset;
+            uint64_t offset;
             VertexFormat format;
         };
 
@@ -187,7 +187,7 @@
             dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
             pass.SetPipeline(pipeline);
 
-            uint32_t zeroOffset = 0;
+            uint64_t zeroOffset = 0;
             for (const auto& buffer : vertexBuffers) {
                 pass.SetVertexBuffers(buffer.location, 1, buffer.buffer, &zeroOffset);
             }
@@ -422,7 +422,7 @@
 
     dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     pass.SetVertexBuffers(0, 1, &buffer, &zeroOffset);
     pass.SetVertexBuffers(1, 1, &buffer, &zeroOffset);
 
@@ -465,7 +465,7 @@
 
     dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
 
-    uint32_t zeroOffset = 0;
+    uint64_t zeroOffset = 0;
     pass.SetVertexBuffers(0, 1, &buffer, &zeroOffset);
     pass.SetVertexBuffers(1, 1, &buffer, &zeroOffset);
 
diff --git a/src/tests/end2end/PrimitiveTopologyTests.cpp b/src/tests/end2end/PrimitiveTopologyTests.cpp
index 490c86c..552715b 100644
--- a/src/tests/end2end/PrimitiveTopologyTests.cpp
+++ b/src/tests/end2end/PrimitiveTopologyTests.cpp
@@ -193,7 +193,7 @@
 
             dawn::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
 
-            static const uint32_t zeroOffset = 0;
+            static const uint64_t zeroOffset = 0;
             dawn::CommandEncoder encoder = device.CreateCommandEncoder();
             {
                 dawn::RenderPassEncoder pass = encoder.BeginRenderPass(
diff --git a/src/tests/unittests/d3d12/CopySplitTests.cpp b/src/tests/unittests/d3d12/CopySplitTests.cpp
index ff55415..5ad1604 100644
--- a/src/tests/unittests/d3d12/CopySplitTests.cpp
+++ b/src/tests/unittests/d3d12/CopySplitTests.cpp
@@ -35,7 +35,7 @@
     };
 
     struct BufferSpec {
-        uint32_t offset;
+        uint64_t offset;
         uint32_t rowPitch;
         uint32_t imageHeight;
     };
diff --git a/src/tests/unittests/validation/BufferValidationTests.cpp b/src/tests/unittests/validation/BufferValidationTests.cpp
index f03f8d3..3d25d67 100644
--- a/src/tests/unittests/validation/BufferValidationTests.cpp
+++ b/src/tests/unittests/validation/BufferValidationTests.cpp
@@ -25,14 +25,14 @@
       MOCK_METHOD4(Call,
                    void(DawnBufferMapAsyncStatus status,
                         const uint32_t* ptr,
-                        uint32_t dataLength,
+                        uint64_t dataLength,
                         DawnCallbackUserdata userdata));
 };
 
 static std::unique_ptr<MockBufferMapReadCallback> mockBufferMapReadCallback;
 static void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
                                         const void* ptr,
-                                        uint32_t dataLength,
+                                        uint64_t dataLength,
                                         DawnCallbackUserdata userdata) {
     // Assume the data is uint32_t to make writing matchers easier
     mockBufferMapReadCallback->Call(status, reinterpret_cast<const uint32_t*>(ptr), dataLength,
@@ -44,14 +44,14 @@
       MOCK_METHOD4(Call,
                    void(DawnBufferMapAsyncStatus status,
                         uint32_t* ptr,
-                        uint32_t dataLength,
+                        uint64_t dataLength,
                         DawnCallbackUserdata userdata));
 };
 
 static std::unique_ptr<MockBufferMapWriteCallback> mockBufferMapWriteCallback;
 static void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
                                          void* ptr,
-                                         uint32_t dataLength,
+                                         uint64_t dataLength,
                                          DawnCallbackUserdata userdata) {
     // Assume the data is uint32_t to make writing matchers easier
     mockBufferMapWriteCallback->Call(status, reinterpret_cast<uint32_t*>(ptr), dataLength,
@@ -60,21 +60,21 @@
 
 class BufferValidationTest : public ValidationTest {
     protected:
-        dawn::Buffer CreateMapReadBuffer(uint32_t size) {
+        dawn::Buffer CreateMapReadBuffer(uint64_t size) {
             dawn::BufferDescriptor descriptor;
             descriptor.size = size;
             descriptor.usage = dawn::BufferUsageBit::MapRead;
 
             return device.CreateBuffer(&descriptor);
         }
-        dawn::Buffer CreateMapWriteBuffer(uint32_t size) {
+        dawn::Buffer CreateMapWriteBuffer(uint64_t size) {
             dawn::BufferDescriptor descriptor;
             descriptor.size = size;
             descriptor.usage = dawn::BufferUsageBit::MapWrite;
 
             return device.CreateBuffer(&descriptor);
         }
-        dawn::Buffer CreateSetSubDataBuffer(uint32_t size) {
+        dawn::Buffer CreateSetSubDataBuffer(uint64_t size) {
             dawn::BufferDescriptor descriptor;
             descriptor.size = size;
             descriptor.usage = dawn::BufferUsageBit::TransferDst;
@@ -455,7 +455,7 @@
 
     // An offset that when added to "2" would overflow to be zero and pass validation without
     // overflow checks.
-    uint32_t offset = uint32_t(int32_t(0) - int32_t(2));
+    uint64_t offset = uint64_t(int64_t(0) - int64_t(2));
 
     ASSERT_DEVICE_ERROR(buf.SetSubData(offset, 2, foo));
 }
@@ -492,7 +492,7 @@
 
     dawn::Buffer buf = device.CreateBuffer(&descriptor);
 
-    uint32_t kOffset = 2999;
+    uint64_t kOffset = 2999;
     uint32_t value = 0x01020304;
     ASSERT_DEVICE_ERROR(buf.SetSubData(kOffset, sizeof(value), reinterpret_cast<uint8_t*>(&value)));
 }
diff --git a/src/tests/unittests/validation/CommandBufferValidationTests.cpp b/src/tests/unittests/validation/CommandBufferValidationTests.cpp
index 3353390..a39989a 100644
--- a/src/tests/unittests/validation/CommandBufferValidationTests.cpp
+++ b/src/tests/unittests/validation/CommandBufferValidationTests.cpp
@@ -180,7 +180,7 @@
     dawn::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
     // Use the buffer as both index and vertex in the same pass
-    uint32_t zero = 0;
+    uint64_t zero = 0;
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
     DummyRenderPass dummyRenderPass(device);
     dawn::RenderPassEncoder pass = encoder.BeginRenderPass(&dummyRenderPass);
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index 8954da6..eccf3b6 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -19,7 +19,7 @@
 
 class CopyCommandTest : public ValidationTest {
     protected:
-        dawn::Buffer CreateBuffer(uint32_t size, dawn::BufferUsageBit usage) {
+        dawn::Buffer CreateBuffer(uint64_t size, dawn::BufferUsageBit usage) {
             dawn::BufferDescriptor descriptor;
             descriptor.size = size;
             descriptor.usage = usage;
@@ -59,7 +59,7 @@
 
         void TestB2TCopy(utils::Expectation expectation,
                          dawn::Buffer srcBuffer,
-                         uint32_t srcOffset,
+                         uint64_t srcOffset,
                          uint32_t srcRowPitch,
                          uint32_t srcImageHeight,
                          dawn::Texture destTexture,
@@ -84,7 +84,7 @@
                          uint32_t srcSlice,
                          dawn::Origin3D srcOrigin,
                          dawn::Buffer destBuffer,
-                         uint32_t destOffset,
+                         uint64_t destOffset,
                          uint32_t destRowPitch,
                          uint32_t destImageHeight,
                          dawn::Extent3D extent3D) {
@@ -228,7 +228,7 @@
     errorBufferDescriptor.usage = dawn::BufferUsageBit::MapRead | dawn::BufferUsageBit::TransferSrc;
     ASSERT_DEVICE_ERROR(dawn::Buffer errorBuffer = device.CreateBuffer(&errorBufferDescriptor));
 
-    constexpr uint32_t bufferSize = 4;
+    constexpr uint64_t bufferSize = 4;
     dawn::Buffer validBuffer = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
 
     {
@@ -249,7 +249,7 @@
 
 // Test a successfull B2T copy
 TEST_F(CopyCommandTest_B2T, Success) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                      dawn::TextureUsageBit::TransferDst);
@@ -302,7 +302,7 @@
 
 // Test OOB conditions on the buffer
 TEST_F(CopyCommandTest_B2T, OutOfBoundsOnBuffer) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                      dawn::TextureUsageBit::TransferDst);
@@ -333,7 +333,7 @@
 
 // Test OOB conditions on the texture
 TEST_F(CopyCommandTest_B2T, OutOfBoundsOnTexture) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(16, 16, 5, 2, dawn::TextureFormat::R8G8B8A8Unorm,
                                                      dawn::TextureUsageBit::TransferDst);
@@ -393,7 +393,7 @@
 }
 
 TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
         dawn::TextureUsageBit::TransferDst);
@@ -412,7 +412,7 @@
 }
 
 TEST_F(CopyCommandTest_B2T, ImageHeightConstraint) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferDst);
@@ -436,7 +436,7 @@
 
 // Test B2T copies with incorrect buffer offset usage
 TEST_F(CopyCommandTest_B2T, IncorrectBufferOffset) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                      dawn::TextureUsageBit::TransferDst);
@@ -458,7 +458,7 @@
 
 // Test multisampled textures cannot be used in B2T copies.
 TEST_F(CopyCommandTest_B2T, CopyToMultisampledTexture) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
     dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
     dawn::Texture destination = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferDst, 4);
@@ -497,7 +497,7 @@
     }
 
     {
-        uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+        uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
         dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
 
         dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0);
@@ -513,7 +513,7 @@
 
 // Test a successfull T2B copy
 TEST_F(CopyCommandTest_T2B, Success) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -566,7 +566,7 @@
 
 // Test OOB conditions on the texture
 TEST_F(CopyCommandTest_T2B, OutOfBoundsOnTexture) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -590,7 +590,7 @@
 
 // Test OOB conditions on the buffer
 TEST_F(CopyCommandTest_T2B, OutOfBoundsOnBuffer) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -620,7 +620,7 @@
 
 // Test that we force Z=0 and Depth=1 on copies from to 2D textures
 TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -636,7 +636,7 @@
 
 // Test T2B copies with incorrect buffer usage
 TEST_F(CopyCommandTest_T2B, IncorrectUsage) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     dawn::Texture source = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                                 dawn::TextureUsageBit::TransferSrc);
     dawn::Texture sampled = Create2DTexture(16, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
@@ -653,7 +653,7 @@
 }
 
 TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
     dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
         dawn::TextureUsageBit::TransferDst);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
@@ -672,7 +672,7 @@
 }
 
 TEST_F(CopyCommandTest_T2B, ImageHeightConstraint) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(5, 5, 1);
     dawn::Texture source = Create2DTexture(16, 16, 1, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                            dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -696,7 +696,7 @@
 
 // Test T2B copies with incorrect buffer offset usage
 TEST_F(CopyCommandTest_T2B, IncorrectBufferOffset) {
-    uint32_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
     dawn::Texture source = Create2DTexture(128, 16, 5, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                            dawn::TextureUsageBit::TransferSrc);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
@@ -718,7 +718,7 @@
 TEST_F(CopyCommandTest_T2B, CopyFromMultisampledTexture) {
     dawn::Texture source = Create2DTexture(2, 2, 1, 1, dawn::TextureFormat::R8G8B8A8Unorm,
                                            dawn::TextureUsageBit::TransferSrc, 4);
-    uint32_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
+    uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
     dawn::Buffer destination = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferDst);
 
     TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
@@ -743,7 +743,7 @@
     dawn::Extent3D extent3D = {1, 1, 1};
 
     {
-        uint32_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
+        uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
         dawn::Buffer source = CreateBuffer(bufferSize, dawn::BufferUsageBit::TransferSrc);
 
         dawn::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(source, 0, 0, 0);
diff --git a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
index 54190c4..556ba18 100644
--- a/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
+++ b/src/tests/unittests/validation/QueueSubmitValidationTests.cpp
@@ -23,7 +23,7 @@
 
 static void StoreTrueMapWriteCallback(DawnBufferMapAsyncStatus status,
                                       void*,
-                                      uint32_t,
+                                      uint64_t,
                                       DawnCallbackUserdata userdata) {
     bool* userdataPtr = reinterpret_cast<bool*>(static_cast<intptr_t>(userdata));
     *userdataPtr = true;
diff --git a/src/tests/unittests/validation/VertexBufferValidationTests.cpp b/src/tests/unittests/validation/VertexBufferValidationTests.cpp
index 3d06cbf..36cbd4d 100644
--- a/src/tests/unittests/validation/VertexBufferValidationTests.cpp
+++ b/src/tests/unittests/validation/VertexBufferValidationTests.cpp
@@ -97,7 +97,7 @@
     auto pipeline1 = MakeRenderPipeline(vsModule1, 1);
 
     auto vertexBuffers = MakeVertexBuffers<2>();
-    uint32_t offsets[] = { 0, 0 };
+    uint64_t offsets[] = { 0, 0 };
 
     // Check failure when vertex buffer is not set
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -132,7 +132,7 @@
     auto pipeline1 = MakeRenderPipeline(vsModule1, 1);
 
     auto vertexBuffers = MakeVertexBuffers<2>();
-    uint32_t offsets[] = { 0, 0 };
+    uint64_t offsets[] = { 0, 0 };
 
     // Check success when vertex buffer is set for each render pass
     dawn::CommandEncoder encoder = device.CreateCommandEncoder();
diff --git a/src/tests/unittests/wire/WireBufferMappingTests.cpp b/src/tests/unittests/wire/WireBufferMappingTests.cpp
index db3c61c..3c4fa88 100644
--- a/src/tests/unittests/wire/WireBufferMappingTests.cpp
+++ b/src/tests/unittests/wire/WireBufferMappingTests.cpp
@@ -25,14 +25,14 @@
         MOCK_METHOD4(Call,
                      void(DawnBufferMapAsyncStatus status,
                           const uint32_t* ptr,
-                          uint32_t dataLength,
+                          uint64_t dataLength,
                           DawnCallbackUserdata userdata));
     };
 
     std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
     void ToMockBufferMapReadCallback(DawnBufferMapAsyncStatus status,
                                      const void* ptr,
-                                     uint32_t dataLength,
+                                     uint64_t dataLength,
                                      DawnCallbackUserdata userdata) {
         // Assume the data is uint32_t to make writing matchers easier
         mockBufferMapReadCallback->Call(status, static_cast<const uint32_t*>(ptr), dataLength,
@@ -44,7 +44,7 @@
         MOCK_METHOD4(Call,
                      void(DawnBufferMapAsyncStatus status,
                           uint32_t* ptr,
-                          uint32_t dataLength,
+                          uint64_t dataLength,
                           DawnCallbackUserdata userdata));
     };
 
@@ -52,7 +52,7 @@
     uint32_t* lastMapWritePointer = nullptr;
     void ToMockBufferMapWriteCallback(DawnBufferMapAsyncStatus status,
                                       void* ptr,
-                                      uint32_t dataLength,
+                                      uint64_t dataLength,
                                       DawnCallbackUserdata userdata) {
         // Assume the data is uint32_t to make writing matchers easier
         lastMapWritePointer = static_cast<uint32_t*>(ptr);
diff --git a/src/utils/DawnHelpers.cpp b/src/utils/DawnHelpers.cpp
index 014bcf1..bea60a6 100644
--- a/src/utils/DawnHelpers.cpp
+++ b/src/utils/DawnHelpers.cpp
@@ -115,7 +115,7 @@
 
     dawn::Buffer CreateBufferFromData(const dawn::Device& device,
                                       const void* data,
-                                      uint32_t size,
+                                      uint64_t size,
                                       dawn::BufferUsageBit usage) {
         dawn::BufferDescriptor descriptor;
         descriptor.size = size;
@@ -234,7 +234,7 @@
     }
 
     dawn::BufferCopyView CreateBufferCopyView(dawn::Buffer buffer,
-                                              uint32_t offset,
+                                              uint64_t offset,
                                               uint32_t rowPitch,
                                               uint32_t imageHeight) {
         dawn::BufferCopyView bufferCopyView;
@@ -319,8 +319,8 @@
 
     BindingInitializationHelper::BindingInitializationHelper(uint32_t binding,
                                                              const dawn::Buffer& buffer,
-                                                             uint32_t offset,
-                                                             uint32_t size)
+                                                             uint64_t offset,
+                                                             uint64_t size)
         : binding(binding), buffer(buffer), offset(offset), size(size) {
     }
 
diff --git a/src/utils/DawnHelpers.h b/src/utils/DawnHelpers.h
index 6a7c83d..8321dad 100644
--- a/src/utils/DawnHelpers.h
+++ b/src/utils/DawnHelpers.h
@@ -33,7 +33,7 @@
 
     dawn::Buffer CreateBufferFromData(const dawn::Device& device,
                                       const void* data,
-                                      uint32_t size,
+                                      uint64_t size,
                                       dawn::BufferUsageBit usage);
 
     template <typename T>
@@ -44,7 +44,7 @@
     }
 
     dawn::BufferCopyView CreateBufferCopyView(dawn::Buffer buffer,
-                                              uint32_t offset,
+                                              uint64_t offset,
                                               uint32_t rowPitch,
                                               uint32_t imageHeight);
     dawn::TextureCopyView CreateTextureCopyView(dawn::Texture texture,
@@ -107,8 +107,8 @@
         BindingInitializationHelper(uint32_t binding, const dawn::TextureView& textureView);
         BindingInitializationHelper(uint32_t binding,
                                     const dawn::Buffer& buffer,
-                                    uint32_t offset,
-                                    uint32_t size);
+                                    uint64_t offset,
+                                    uint64_t size);
 
         dawn::BindGroupBinding GetAsBinding() const;
 
@@ -116,8 +116,8 @@
         dawn::Sampler sampler;
         dawn::TextureView textureView;
         dawn::Buffer buffer;
-        uint32_t offset = 0;
-        uint32_t size = 0;
+        uint64_t offset = 0;
+        uint64_t size = 0;
     };
 
     dawn::BindGroup MakeBindGroup(
@@ -127,4 +127,4 @@
 
 }  // namespace utils
 
-#endif  // UTILS_DAWNHELPERS_H_
\ No newline at end of file
+#endif  // UTILS_DAWNHELPERS_H_