diff --git a/dawn.json b/dawn.json
index afee3f3..d81172e 100644
--- a/dawn.json
+++ b/dawn.json
@@ -597,16 +597,16 @@
             {"name": "flipY", "type": "bool", "default": "false"}
         ]
     },
-    "create ready compute pipeline callback": {
+    "create compute pipeline async callback": {
         "category": "callback",
         "args": [
-            {"name": "status", "type": "create ready pipeline status"},
+            {"name": "status", "type": "create pipeline async status"},
             {"name": "pipeline", "type": "compute pipeline"},
             {"name": "message", "type": "char", "annotation": "const*", "length": "strlen"},
             {"name": "userdata", "type": "void", "annotation": "*"}
         ]
     },
-    "create ready pipeline status": {
+    "create pipeline async status": {
         "category": "enum",
         "values": [
             {"value": 0, "name": "success"},
@@ -616,10 +616,10 @@
             {"value": 4, "name": "unknown"}
         ]
     },
-    "create ready render pipeline callback": {
+    "create render pipeline async callback": {
         "category": "callback",
         "args": [
-            {"name": "status", "type": "create ready pipeline status"},
+            {"name": "status", "type": "create pipeline async status"},
             {"name": "pipeline", "type": "render pipeline"},
             {"name": "message", "type": "char", "annotation": "const*", "length": "strlen"},
             {"name": "userdata", "type": "void", "annotation": "*"}
@@ -677,11 +677,11 @@
                 ]
             },
             {
-                "name": "create ready compute pipeline",
+                "name": "create compute pipeline async",
                 "returns": "void",
                 "args": [
                     {"name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"},
-                    {"name": "callback", "type": "create ready compute pipeline callback"},
+                    {"name": "callback", "type": "create compute pipeline async callback"},
                     {"name": "userdata", "type": "void", "annotation": "*"}
                 ]
             },
@@ -700,11 +700,11 @@
                 ]
             },
             {
-                "name": "create ready render pipeline",
+                "name": "create render pipeline async",
                 "returns": "void",
                 "args": [
                     {"name": "descriptor", "type": "render pipeline descriptor", "annotation": "const*"},
-                    {"name": "callback", "type": "create ready render pipeline callback"},
+                    {"name": "callback", "type": "create render pipeline async callback"},
                     {"name": "userdata", "type": "void", "annotation": "*"}
                 ]
             },
diff --git a/dawn_wire.json b/dawn_wire.json
index 4294ed4..98b4596 100644
--- a/dawn_wire.json
+++ b/dawn_wire.json
@@ -36,13 +36,13 @@
             { "name": "handle create info length", "type": "uint64_t" },
             { "name": "handle create info", "type": "uint8_t", "annotation": "const*", "length": "handle create info length", "skip_serialize": true}
         ],
-        "device create ready compute pipeline": [
+        "device create compute pipeline async": [
             { "name": "device id", "type": "ObjectId" },
             { "name": "request serial", "type": "uint64_t" },
             { "name": "pipeline object handle", "type": "ObjectHandle", "handle_type": "compute pipeline"},
             { "name": "descriptor", "type": "compute pipeline descriptor", "annotation": "const*"}
         ],
-        "device create ready render pipeline": [
+        "device create render pipeline async": [
             { "name": "device id", "type": "ObjectId" },
             { "name": "request serial", "type": "uint64_t" },
             { "name": "pipeline object handle", "type": "ObjectHandle", "handle_type": "render pipeline"},
@@ -85,16 +85,16 @@
             { "name": "read initial data info length", "type": "uint64_t" },
             { "name": "read initial data info", "type": "uint8_t", "annotation": "const*", "length": "read initial data info length", "skip_serialize": true }
         ],
-        "device create ready compute pipeline callback": [
+        "device create compute pipeline async callback": [
             { "name": "device", "type": "ObjectHandle", "handle_type": "device" },
             { "name": "request serial", "type": "uint64_t" },
-            { "name": "status", "type": "create ready pipeline status" },
+            { "name": "status", "type": "create pipeline async status" },
             { "name": "message", "type": "char", "annotation": "const*", "length": "strlen" }
         ],
-        "device create ready render pipeline callback": [
+        "device create render pipeline async callback": [
             { "name": "device", "type": "ObjectHandle", "handle_type": "device" },
             { "name": "request serial", "type": "uint64_t" },
-            { "name": "status", "type": "create ready pipeline status" },
+            { "name": "status", "type": "create pipeline async status" },
             { "name": "message", "type": "char", "annotation": "const*", "length": "strlen" }
         ],
         "device uncaptured error callback": [
@@ -133,8 +133,8 @@
             "BufferGetConstMappedRange",
             "BufferGetMappedRange",
             "DeviceCreateBuffer",
-            "DeviceCreateReadyComputePipeline",
-            "DeviceCreateReadyRenderPipeline",
+            "DeviceCreateComputePipelineAsync",
+            "DeviceCreateRenderPipelineAsync",
             "DevicePopErrorScope",
             "DeviceSetDeviceLostCallback",
             "DeviceSetUncapturedErrorCallback",
diff --git a/src/dawn_native/BUILD.gn b/src/dawn_native/BUILD.gn
index 77afa36..b708e66 100644
--- a/src/dawn_native/BUILD.gn
+++ b/src/dawn_native/BUILD.gn
@@ -199,8 +199,8 @@
     "ComputePipeline.h",
     "CopyTextureForBrowserHelper.cpp",
     "CopyTextureForBrowserHelper.h",
-    "CreateReadyPipelineTracker.cpp",
-    "CreateReadyPipelineTracker.h",
+    "CreatePipelineAsyncTracker.cpp",
+    "CreatePipelineAsyncTracker.h",
     "Device.cpp",
     "Device.h",
     "DynamicUploader.cpp",
diff --git a/src/dawn_native/CMakeLists.txt b/src/dawn_native/CMakeLists.txt
index 91c474c..ea3684e 100644
--- a/src/dawn_native/CMakeLists.txt
+++ b/src/dawn_native/CMakeLists.txt
@@ -72,8 +72,8 @@
     "ComputePipeline.h"
     "CopyTextureForBrowserHelper.cpp"
     "CopyTextureForBrowserHelper.h"
-    "CreateReadyPipelineTracker.cpp"
-    "CreateReadyPipelineTracker.h"
+    "CreatePipelineAsyncTracker.cpp"
+    "CreatePipelineAsyncTracker.h"
     "Device.cpp"
     "Device.h"
     "DynamicUploader.cpp"
diff --git a/src/dawn_native/CreatePipelineAsyncTracker.cpp b/src/dawn_native/CreatePipelineAsyncTracker.cpp
new file mode 100644
index 0000000..7239774
--- /dev/null
+++ b/src/dawn_native/CreatePipelineAsyncTracker.cpp
@@ -0,0 +1,114 @@
+// Copyright 2020 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dawn_native/CreatePipelineAsyncTracker.h"
+
+#include "dawn_native/ComputePipeline.h"
+#include "dawn_native/Device.h"
+#include "dawn_native/RenderPipeline.h"
+
+namespace dawn_native {
+
+    CreatePipelineAsyncTaskBase::CreatePipelineAsyncTaskBase(void* userdata) : mUserData(userdata) {
+    }
+
+    CreatePipelineAsyncTaskBase::~CreatePipelineAsyncTaskBase() {
+    }
+
+    CreateComputePipelineAsyncTask::CreateComputePipelineAsyncTask(
+        ComputePipelineBase* pipeline,
+        WGPUCreateComputePipelineAsyncCallback callback,
+        void* userdata)
+        : CreatePipelineAsyncTaskBase(userdata),
+          mPipeline(pipeline),
+          mCreateComputePipelineAsyncCallback(callback) {
+    }
+
+    void CreateComputePipelineAsyncTask::Finish(WGPUCreatePipelineAsyncStatus status) {
+        ASSERT(mPipeline != nullptr);
+        ASSERT(mCreateComputePipelineAsyncCallback != nullptr);
+
+        if (status != WGPUCreatePipelineAsyncStatus_Success) {
+            // TODO(jiawei.shao@intel.com): support handling device lost
+            ASSERT(status == WGPUCreatePipelineAsyncStatus_DeviceDestroyed);
+            mCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus_DeviceDestroyed,
+                                                nullptr, "Device destroyed before callback",
+                                                mUserData);
+            mPipeline->Release();
+        } else {
+            mCreateComputePipelineAsyncCallback(
+                status, reinterpret_cast<WGPUComputePipeline>(mPipeline), "", mUserData);
+        }
+
+        // Set mCreateComputePipelineAsyncCallback to nullptr in case it is called more than once.
+        mCreateComputePipelineAsyncCallback = nullptr;
+    }
+
+    CreateRenderPipelineAsyncTask::CreateRenderPipelineAsyncTask(
+        RenderPipelineBase* pipeline,
+        WGPUCreateRenderPipelineAsyncCallback callback,
+        void* userdata)
+        : CreatePipelineAsyncTaskBase(userdata),
+          mPipeline(pipeline),
+          mCreateRenderPipelineAsyncCallback(callback) {
+    }
+
+    void CreateRenderPipelineAsyncTask::Finish(WGPUCreatePipelineAsyncStatus status) {
+        ASSERT(mPipeline != nullptr);
+        ASSERT(mCreateRenderPipelineAsyncCallback != nullptr);
+
+        if (status != WGPUCreatePipelineAsyncStatus_Success) {
+            // TODO(jiawei.shao@intel.com): support handling device lost
+            ASSERT(status == WGPUCreatePipelineAsyncStatus_DeviceDestroyed);
+            mCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus_DeviceDestroyed,
+                                               nullptr, "Device destroyed before callback",
+                                               mUserData);
+            mPipeline->Release();
+        } else {
+            mCreateRenderPipelineAsyncCallback(
+                status, reinterpret_cast<WGPURenderPipeline>(mPipeline), "", mUserData);
+        }
+
+        // Set mCreatePipelineAsyncCallback to nullptr in case it is called more than once.
+        mCreateRenderPipelineAsyncCallback = nullptr;
+    }
+
+    CreatePipelineAsyncTracker::CreatePipelineAsyncTracker(DeviceBase* device) : mDevice(device) {
+    }
+
+    CreatePipelineAsyncTracker::~CreatePipelineAsyncTracker() {
+        ASSERT(mCreatePipelineAsyncTasksInFlight.Empty());
+    }
+
+    void CreatePipelineAsyncTracker::TrackTask(std::unique_ptr<CreatePipelineAsyncTaskBase> task,
+                                               ExecutionSerial serial) {
+        mCreatePipelineAsyncTasksInFlight.Enqueue(std::move(task), serial);
+        mDevice->AddFutureSerial(serial);
+    }
+
+    void CreatePipelineAsyncTracker::Tick(ExecutionSerial finishedSerial) {
+        for (auto& task : mCreatePipelineAsyncTasksInFlight.IterateUpTo(finishedSerial)) {
+            task->Finish(WGPUCreatePipelineAsyncStatus_Success);
+        }
+        mCreatePipelineAsyncTasksInFlight.ClearUpTo(finishedSerial);
+    }
+
+    void CreatePipelineAsyncTracker::ClearForShutDown() {
+        for (auto& task : mCreatePipelineAsyncTasksInFlight.IterateAll()) {
+            task->Finish(WGPUCreatePipelineAsyncStatus_DeviceDestroyed);
+        }
+        mCreatePipelineAsyncTasksInFlight.Clear();
+    }
+
+}  // namespace dawn_native
diff --git a/src/dawn_native/CreatePipelineAsyncTracker.h b/src/dawn_native/CreatePipelineAsyncTracker.h
new file mode 100644
index 0000000..73e366c
--- /dev/null
+++ b/src/dawn_native/CreatePipelineAsyncTracker.h
@@ -0,0 +1,82 @@
+// Copyright 2020 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_
+#define DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_
+
+#include "common/SerialQueue.h"
+#include "dawn/webgpu.h"
+#include "dawn_native/IntegerTypes.h"
+
+#include <memory>
+
+namespace dawn_native {
+
+    class ComputePipelineBase;
+    class DeviceBase;
+    class PipelineBase;
+    class RenderPipelineBase;
+
+    struct CreatePipelineAsyncTaskBase {
+        CreatePipelineAsyncTaskBase(void* userData);
+        virtual ~CreatePipelineAsyncTaskBase();
+
+        virtual void Finish(WGPUCreatePipelineAsyncStatus status) = 0;
+
+      protected:
+        void* mUserData;
+    };
+
+    struct CreateComputePipelineAsyncTask final : public CreatePipelineAsyncTaskBase {
+        CreateComputePipelineAsyncTask(ComputePipelineBase* pipeline,
+                                       WGPUCreateComputePipelineAsyncCallback callback,
+                                       void* userdata);
+
+        void Finish(WGPUCreatePipelineAsyncStatus status) final;
+
+      private:
+        ComputePipelineBase* mPipeline;
+        WGPUCreateComputePipelineAsyncCallback mCreateComputePipelineAsyncCallback;
+    };
+
+    struct CreateRenderPipelineAsyncTask final : public CreatePipelineAsyncTaskBase {
+        CreateRenderPipelineAsyncTask(RenderPipelineBase* pipeline,
+                                      WGPUCreateRenderPipelineAsyncCallback callback,
+                                      void* userdata);
+
+        void Finish(WGPUCreatePipelineAsyncStatus status) final;
+
+      private:
+        RenderPipelineBase* mPipeline;
+        WGPUCreateRenderPipelineAsyncCallback mCreateRenderPipelineAsyncCallback;
+    };
+
+    class CreatePipelineAsyncTracker {
+      public:
+        CreatePipelineAsyncTracker(DeviceBase* device);
+        ~CreatePipelineAsyncTracker();
+
+        void TrackTask(std::unique_ptr<CreatePipelineAsyncTaskBase> task, ExecutionSerial serial);
+        void Tick(ExecutionSerial finishedSerial);
+        void ClearForShutDown();
+
+      private:
+        DeviceBase* mDevice;
+        SerialQueue<ExecutionSerial, std::unique_ptr<CreatePipelineAsyncTaskBase>>
+            mCreatePipelineAsyncTasksInFlight;
+    };
+
+}  // namespace dawn_native
+
+#endif  // DAWNNATIVE_CREATEPIPELINEASYNCTRACKER_H_
diff --git a/src/dawn_native/CreateReadyPipelineTracker.cpp b/src/dawn_native/CreateReadyPipelineTracker.cpp
deleted file mode 100644
index be64393..0000000
--- a/src/dawn_native/CreateReadyPipelineTracker.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright 2020 The Dawn Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "dawn_native/CreateReadyPipelineTracker.h"
-
-#include "dawn_native/ComputePipeline.h"
-#include "dawn_native/Device.h"
-#include "dawn_native/RenderPipeline.h"
-
-namespace dawn_native {
-
-    CreateReadyPipelineTaskBase::CreateReadyPipelineTaskBase(void* userdata) : mUserData(userdata) {
-    }
-
-    CreateReadyPipelineTaskBase::~CreateReadyPipelineTaskBase() {
-    }
-
-    CreateReadyComputePipelineTask::CreateReadyComputePipelineTask(
-        ComputePipelineBase* pipeline,
-        WGPUCreateReadyComputePipelineCallback callback,
-        void* userdata)
-        : CreateReadyPipelineTaskBase(userdata),
-          mPipeline(pipeline),
-          mCreateReadyComputePipelineCallback(callback) {
-    }
-
-    void CreateReadyComputePipelineTask::Finish(WGPUCreateReadyPipelineStatus status) {
-        ASSERT(mPipeline != nullptr);
-        ASSERT(mCreateReadyComputePipelineCallback != nullptr);
-
-        if (status != WGPUCreateReadyPipelineStatus_Success) {
-            // TODO(jiawei.shao@intel.com): support handling device lost
-            ASSERT(status == WGPUCreateReadyPipelineStatus_DeviceDestroyed);
-            mCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus_DeviceDestroyed,
-                                                nullptr, "Device destroyed before callback",
-                                                mUserData);
-            mPipeline->Release();
-        } else {
-            mCreateReadyComputePipelineCallback(
-                status, reinterpret_cast<WGPUComputePipeline>(mPipeline), "", mUserData);
-        }
-
-        // Set mCreateReadyComputePipelineCallback to nullptr in case it is called more than once.
-        mCreateReadyComputePipelineCallback = nullptr;
-    }
-
-    CreateReadyRenderPipelineTask::CreateReadyRenderPipelineTask(
-        RenderPipelineBase* pipeline,
-        WGPUCreateReadyRenderPipelineCallback callback,
-        void* userdata)
-        : CreateReadyPipelineTaskBase(userdata),
-          mPipeline(pipeline),
-          mCreateReadyRenderPipelineCallback(callback) {
-    }
-
-    void CreateReadyRenderPipelineTask::Finish(WGPUCreateReadyPipelineStatus status) {
-        ASSERT(mPipeline != nullptr);
-        ASSERT(mCreateReadyRenderPipelineCallback != nullptr);
-
-        if (status != WGPUCreateReadyPipelineStatus_Success) {
-            // TODO(jiawei.shao@intel.com): support handling device lost
-            ASSERT(status == WGPUCreateReadyPipelineStatus_DeviceDestroyed);
-            mCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus_DeviceDestroyed,
-                                               nullptr, "Device destroyed before callback",
-                                               mUserData);
-            mPipeline->Release();
-        } else {
-            mCreateReadyRenderPipelineCallback(
-                status, reinterpret_cast<WGPURenderPipeline>(mPipeline), "", mUserData);
-        }
-
-        // Set mCreateReadyPipelineCallback to nullptr in case it is called more than once.
-        mCreateReadyRenderPipelineCallback = nullptr;
-    }
-
-    CreateReadyPipelineTracker::CreateReadyPipelineTracker(DeviceBase* device) : mDevice(device) {
-    }
-
-    CreateReadyPipelineTracker::~CreateReadyPipelineTracker() {
-        ASSERT(mCreateReadyPipelineTasksInFlight.Empty());
-    }
-
-    void CreateReadyPipelineTracker::TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task,
-                                               ExecutionSerial serial) {
-        mCreateReadyPipelineTasksInFlight.Enqueue(std::move(task), serial);
-        mDevice->AddFutureSerial(serial);
-    }
-
-    void CreateReadyPipelineTracker::Tick(ExecutionSerial finishedSerial) {
-        for (auto& task : mCreateReadyPipelineTasksInFlight.IterateUpTo(finishedSerial)) {
-            task->Finish(WGPUCreateReadyPipelineStatus_Success);
-        }
-        mCreateReadyPipelineTasksInFlight.ClearUpTo(finishedSerial);
-    }
-
-    void CreateReadyPipelineTracker::ClearForShutDown() {
-        for (auto& task : mCreateReadyPipelineTasksInFlight.IterateAll()) {
-            task->Finish(WGPUCreateReadyPipelineStatus_DeviceDestroyed);
-        }
-        mCreateReadyPipelineTasksInFlight.Clear();
-    }
-
-}  // namespace dawn_native
diff --git a/src/dawn_native/CreateReadyPipelineTracker.h b/src/dawn_native/CreateReadyPipelineTracker.h
deleted file mode 100644
index b1eed08..0000000
--- a/src/dawn_native/CreateReadyPipelineTracker.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2020 The Dawn Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef DAWNNATIVE_CREATEREADYPIPELINETRACKER_H_
-#define DAWNNATIVE_CREATEREADYPIPELINETRACKER_H_
-
-#include "common/SerialQueue.h"
-#include "dawn/webgpu.h"
-#include "dawn_native/IntegerTypes.h"
-
-#include <memory>
-
-namespace dawn_native {
-
-    class ComputePipelineBase;
-    class DeviceBase;
-    class PipelineBase;
-    class RenderPipelineBase;
-
-    struct CreateReadyPipelineTaskBase {
-        CreateReadyPipelineTaskBase(void* userData);
-        virtual ~CreateReadyPipelineTaskBase();
-
-        virtual void Finish(WGPUCreateReadyPipelineStatus status) = 0;
-
-      protected:
-        void* mUserData;
-    };
-
-    struct CreateReadyComputePipelineTask final : public CreateReadyPipelineTaskBase {
-        CreateReadyComputePipelineTask(ComputePipelineBase* pipeline,
-                                       WGPUCreateReadyComputePipelineCallback callback,
-                                       void* userdata);
-
-        void Finish(WGPUCreateReadyPipelineStatus status) final;
-
-      private:
-        ComputePipelineBase* mPipeline;
-        WGPUCreateReadyComputePipelineCallback mCreateReadyComputePipelineCallback;
-    };
-
-    struct CreateReadyRenderPipelineTask final : public CreateReadyPipelineTaskBase {
-        CreateReadyRenderPipelineTask(RenderPipelineBase* pipeline,
-                                      WGPUCreateReadyRenderPipelineCallback callback,
-                                      void* userdata);
-
-        void Finish(WGPUCreateReadyPipelineStatus status) final;
-
-      private:
-        RenderPipelineBase* mPipeline;
-        WGPUCreateReadyRenderPipelineCallback mCreateReadyRenderPipelineCallback;
-    };
-
-    class CreateReadyPipelineTracker {
-      public:
-        CreateReadyPipelineTracker(DeviceBase* device);
-        ~CreateReadyPipelineTracker();
-
-        void TrackTask(std::unique_ptr<CreateReadyPipelineTaskBase> task, ExecutionSerial serial);
-        void Tick(ExecutionSerial finishedSerial);
-        void ClearForShutDown();
-
-      private:
-        DeviceBase* mDevice;
-        SerialQueue<ExecutionSerial, std::unique_ptr<CreateReadyPipelineTaskBase>>
-            mCreateReadyPipelineTasksInFlight;
-    };
-
-}  // namespace dawn_native
-
-#endif
diff --git a/src/dawn_native/Device.cpp b/src/dawn_native/Device.cpp
index d2fdd97..7e33e3f 100644
--- a/src/dawn_native/Device.cpp
+++ b/src/dawn_native/Device.cpp
@@ -23,7 +23,7 @@
 #include "dawn_native/CommandBuffer.h"
 #include "dawn_native/CommandEncoder.h"
 #include "dawn_native/ComputePipeline.h"
-#include "dawn_native/CreateReadyPipelineTracker.h"
+#include "dawn_native/CreatePipelineAsyncTracker.h"
 #include "dawn_native/DynamicUploader.h"
 #include "dawn_native/ErrorData.h"
 #include "dawn_native/ErrorScope.h"
@@ -123,7 +123,7 @@
         mCaches = std::make_unique<DeviceBase::Caches>();
         mErrorScopeStack = std::make_unique<ErrorScopeStack>();
         mDynamicUploader = std::make_unique<DynamicUploader>(this);
-        mCreateReadyPipelineTracker = std::make_unique<CreateReadyPipelineTracker>(this);
+        mCreatePipelineAsyncTracker = std::make_unique<CreatePipelineAsyncTracker>(this);
         mDeprecationWarnings = std::make_unique<DeprecationWarnings>();
         mInternalPipelineStore = std::make_unique<InternalPipelineStore>();
         mPersistentCache = std::make_unique<PersistentCache>(this);
@@ -141,7 +141,7 @@
         // Skip handling device facilities if they haven't even been created (or failed doing so)
         if (mState != State::BeingCreated) {
             // Reject all async pipeline creations.
-            mCreateReadyPipelineTracker->ClearForShutDown();
+            mCreatePipelineAsyncTracker->ClearForShutDown();
         }
 
         // Disconnect the device, depending on which state we are currently in.
@@ -186,7 +186,7 @@
         mState = State::Disconnected;
 
         mDynamicUploader = nullptr;
-        mCreateReadyPipelineTracker = nullptr;
+        mCreatePipelineAsyncTracker = nullptr;
         mPersistentCache = nullptr;
 
         mEmptyBindGroupLayout = nullptr;
@@ -705,21 +705,21 @@
 
         return result;
     }
-    void DeviceBase::CreateReadyComputePipeline(const ComputePipelineDescriptor* descriptor,
-                                                WGPUCreateReadyComputePipelineCallback callback,
+    void DeviceBase::CreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor,
+                                                WGPUCreateComputePipelineAsyncCallback callback,
                                                 void* userdata) {
         ComputePipelineBase* result = nullptr;
         MaybeError maybeError = CreateComputePipelineInternal(&result, descriptor);
         if (maybeError.IsError()) {
             std::unique_ptr<ErrorData> error = maybeError.AcquireError();
-            callback(WGPUCreateReadyPipelineStatus_Error, nullptr, error->GetMessage().c_str(),
+            callback(WGPUCreatePipelineAsyncStatus_Error, nullptr, error->GetMessage().c_str(),
                      userdata);
             return;
         }
 
-        std::unique_ptr<CreateReadyComputePipelineTask> request =
-            std::make_unique<CreateReadyComputePipelineTask>(result, callback, userdata);
-        mCreateReadyPipelineTracker->TrackTask(std::move(request), GetPendingCommandSerial());
+        std::unique_ptr<CreateComputePipelineAsyncTask> request =
+            std::make_unique<CreateComputePipelineAsyncTask>(result, callback, userdata);
+        mCreatePipelineAsyncTracker->TrackTask(std::move(request), GetPendingCommandSerial());
     }
     PipelineLayoutBase* DeviceBase::CreatePipelineLayout(
         const PipelineLayoutDescriptor* descriptor) {
@@ -749,21 +749,21 @@
 
         return result;
     }
-    void DeviceBase::CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor,
-                                               WGPUCreateReadyRenderPipelineCallback callback,
+    void DeviceBase::CreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor,
+                                               WGPUCreateRenderPipelineAsyncCallback callback,
                                                void* userdata) {
         RenderPipelineBase* result = nullptr;
         MaybeError maybeError = CreateRenderPipelineInternal(&result, descriptor);
         if (maybeError.IsError()) {
             std::unique_ptr<ErrorData> error = maybeError.AcquireError();
-            callback(WGPUCreateReadyPipelineStatus_Error, nullptr, error->GetMessage().c_str(),
+            callback(WGPUCreatePipelineAsyncStatus_Error, nullptr, error->GetMessage().c_str(),
                      userdata);
             return;
         }
 
-        std::unique_ptr<CreateReadyRenderPipelineTask> request =
-            std::make_unique<CreateReadyRenderPipelineTask>(result, callback, userdata);
-        mCreateReadyPipelineTracker->TrackTask(std::move(request), GetPendingCommandSerial());
+        std::unique_ptr<CreateRenderPipelineAsyncTask> request =
+            std::make_unique<CreateRenderPipelineAsyncTask>(result, callback, userdata);
+        mCreatePipelineAsyncTracker->TrackTask(std::move(request), GetPendingCommandSerial());
     }
     RenderBundleEncoder* DeviceBase::CreateRenderBundleEncoder(
         const RenderBundleEncoderDescriptor* descriptor) {
@@ -862,7 +862,7 @@
             mDynamicUploader->Deallocate(mCompletedSerial);
             GetQueue()->Tick(mCompletedSerial);
 
-            mCreateReadyPipelineTracker->Tick(mCompletedSerial);
+            mCreatePipelineAsyncTracker->Tick(mCompletedSerial);
         }
 
         return !IsDeviceIdle();
diff --git a/src/dawn_native/Device.h b/src/dawn_native/Device.h
index 3a830d9..7764ec6 100644
--- a/src/dawn_native/Device.h
+++ b/src/dawn_native/Device.h
@@ -33,7 +33,7 @@
     class AttachmentState;
     class AttachmentStateBlueprint;
     class BindGroupLayoutBase;
-    class CreateReadyPipelineTracker;
+    class CreatePipelineAsyncTracker;
     class DynamicUploader;
     class ErrorScopeStack;
     class PersistentCache;
@@ -146,11 +146,11 @@
         ComputePipelineBase* CreateComputePipeline(const ComputePipelineDescriptor* descriptor);
         PipelineLayoutBase* CreatePipelineLayout(const PipelineLayoutDescriptor* descriptor);
         QuerySetBase* CreateQuerySet(const QuerySetDescriptor* descriptor);
-        void CreateReadyComputePipeline(const ComputePipelineDescriptor* descriptor,
-                                        WGPUCreateReadyComputePipelineCallback callback,
+        void CreateComputePipelineAsync(const ComputePipelineDescriptor* descriptor,
+                                        WGPUCreateComputePipelineAsyncCallback callback,
                                         void* userdata);
-        void CreateReadyRenderPipeline(const RenderPipelineDescriptor* descriptor,
-                                       WGPUCreateReadyRenderPipelineCallback callback,
+        void CreateRenderPipelineAsync(const RenderPipelineDescriptor* descriptor,
+                                       WGPUCreateRenderPipelineAsyncCallback callback,
                                        void* userdata);
         RenderBundleEncoder* CreateRenderBundleEncoder(
             const RenderBundleEncoderDescriptor* descriptor);
@@ -381,7 +381,7 @@
         Ref<BindGroupLayoutBase> mEmptyBindGroupLayout;
 
         std::unique_ptr<DynamicUploader> mDynamicUploader;
-        std::unique_ptr<CreateReadyPipelineTracker> mCreateReadyPipelineTracker;
+        std::unique_ptr<CreatePipelineAsyncTracker> mCreatePipelineAsyncTracker;
         Ref<QueueBase> mQueue;
 
         struct DeprecationWarnings;
diff --git a/src/dawn_wire/client/ClientDoers.cpp b/src/dawn_wire/client/ClientDoers.cpp
index d86d13e..a5ef7f6 100644
--- a/src/dawn_wire/client/ClientDoers.cpp
+++ b/src/dawn_wire/client/ClientDoers.cpp
@@ -93,26 +93,26 @@
         return true;
     }
 
-    bool Client::DoDeviceCreateReadyComputePipelineCallback(Device* device,
+    bool Client::DoDeviceCreateComputePipelineAsyncCallback(Device* device,
                                                             uint64_t requestSerial,
-                                                            WGPUCreateReadyPipelineStatus status,
+                                                            WGPUCreatePipelineAsyncStatus status,
                                                             const char* message) {
         // The device might have been deleted or recreated so this isn't an error.
         if (device == nullptr) {
             return true;
         }
-        return device->OnCreateReadyComputePipelineCallback(requestSerial, status, message);
+        return device->OnCreateComputePipelineAsyncCallback(requestSerial, status, message);
     }
 
-    bool Client::DoDeviceCreateReadyRenderPipelineCallback(Device* device,
+    bool Client::DoDeviceCreateRenderPipelineAsyncCallback(Device* device,
                                                            uint64_t requestSerial,
-                                                           WGPUCreateReadyPipelineStatus status,
+                                                           WGPUCreatePipelineAsyncStatus status,
                                                            const char* message) {
         // The device might have been deleted or recreated so this isn't an error.
         if (device == nullptr) {
             return true;
         }
-        return device->OnCreateReadyRenderPipelineCallback(requestSerial, status, message);
+        return device->OnCreateRenderPipelineAsyncCallback(requestSerial, status, message);
     }
 
 }}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Device.cpp b/src/dawn_wire/client/Device.cpp
index cbd661d..3a9189e 100644
--- a/src/dawn_wire/client/Device.cpp
+++ b/src/dawn_wire/client/Device.cpp
@@ -55,16 +55,16 @@
                                it.second.userdata);
         }
 
-        auto createReadyPipelineRequests = std::move(mCreateReadyPipelineRequests);
-        for (const auto& it : createReadyPipelineRequests) {
-            if (it.second.createReadyComputePipelineCallback != nullptr) {
-                it.second.createReadyComputePipelineCallback(
-                    WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr,
+        auto createPipelineAsyncRequests = std::move(mCreatePipelineAsyncRequests);
+        for (const auto& it : createPipelineAsyncRequests) {
+            if (it.second.createComputePipelineAsyncCallback != nullptr) {
+                it.second.createComputePipelineAsyncCallback(
+                    WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr,
                     "Device destroyed before callback", it.second.userdata);
             } else {
-                ASSERT(it.second.createReadyRenderPipelineCallback != nullptr);
-                it.second.createReadyRenderPipelineCallback(
-                    WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr,
+                ASSERT(it.second.createRenderPipelineAsyncCallback != nullptr);
+                it.second.createRenderPipelineAsyncCallback(
+                    WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr,
                     "Device destroyed before callback", it.second.userdata);
             }
         }
@@ -84,20 +84,20 @@
     }
 
     void Device::CancelCallbacksForDisconnect() {
-        for (auto& it : mCreateReadyPipelineRequests) {
-            ASSERT((it.second.createReadyComputePipelineCallback != nullptr) ^
-                   (it.second.createReadyRenderPipelineCallback != nullptr));
-            if (it.second.createReadyRenderPipelineCallback) {
-                it.second.createReadyRenderPipelineCallback(
-                    WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost",
+        for (auto& it : mCreatePipelineAsyncRequests) {
+            ASSERT((it.second.createComputePipelineAsyncCallback != nullptr) ^
+                   (it.second.createRenderPipelineAsyncCallback != nullptr));
+            if (it.second.createRenderPipelineAsyncCallback) {
+                it.second.createRenderPipelineAsyncCallback(
+                    WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost",
                     it.second.userdata);
             } else {
-                it.second.createReadyComputePipelineCallback(
-                    WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, "Device lost",
+                it.second.createComputePipelineAsyncCallback(
+                    WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, "Device lost",
                     it.second.userdata);
             }
         }
-        mCreateReadyPipelineRequests.clear();
+        mCreatePipelineAsyncRequests.clear();
 
         for (auto& it : mErrorScopes) {
             it.second.callback(WGPUErrorType_DeviceLost, "Device lost", it.second.userdata);
@@ -221,113 +221,113 @@
         return GetQueue();
     }
 
-    void Device::CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor,
-                                            WGPUCreateReadyComputePipelineCallback callback,
+    void Device::CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
+                                            WGPUCreateComputePipelineAsyncCallback callback,
                                             void* userdata) {
         if (client->IsDisconnected()) {
-            return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
+            return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr,
                             "GPU device disconnected", userdata);
         }
 
-        DeviceCreateReadyComputePipelineCmd cmd;
+        DeviceCreateComputePipelineAsyncCmd cmd;
         cmd.deviceId = this->id;
         cmd.descriptor = descriptor;
 
-        uint64_t serial = mCreateReadyPipelineRequestSerial++;
-        ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
+        uint64_t serial = mCreatePipelineAsyncRequestSerial++;
+        ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end());
         cmd.requestSerial = serial;
 
         auto* allocation = client->ComputePipelineAllocator().New(client);
-        CreateReadyPipelineRequest request = {};
-        request.createReadyComputePipelineCallback = callback;
+        CreatePipelineAsyncRequest request = {};
+        request.createComputePipelineAsyncCallback = callback;
         request.userdata = userdata;
         request.pipelineObjectID = allocation->object->id;
 
         cmd.pipelineObjectHandle = ObjectHandle{allocation->object->id, allocation->generation};
         client->SerializeCommand(cmd);
 
-        mCreateReadyPipelineRequests[serial] = std::move(request);
+        mCreatePipelineAsyncRequests[serial] = std::move(request);
     }
 
-    bool Device::OnCreateReadyComputePipelineCallback(uint64_t requestSerial,
-                                                      WGPUCreateReadyPipelineStatus status,
+    bool Device::OnCreateComputePipelineAsyncCallback(uint64_t requestSerial,
+                                                      WGPUCreatePipelineAsyncStatus status,
                                                       const char* message) {
-        const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial);
-        if (requestIt == mCreateReadyPipelineRequests.end()) {
+        const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial);
+        if (requestIt == mCreatePipelineAsyncRequests.end()) {
             return false;
         }
 
-        CreateReadyPipelineRequest request = std::move(requestIt->second);
-        mCreateReadyPipelineRequests.erase(requestIt);
+        CreatePipelineAsyncRequest request = std::move(requestIt->second);
+        mCreatePipelineAsyncRequests.erase(requestIt);
 
         auto pipelineAllocation =
             client->ComputePipelineAllocator().GetObject(request.pipelineObjectID);
 
         // If the return status is a failure we should give a null pipeline to the callback and
         // free the allocation both on the client side and the server side.
-        if (status != WGPUCreateReadyPipelineStatus_Success) {
+        if (status != WGPUCreatePipelineAsyncStatus_Success) {
             client->ComputePipelineAllocator().Free(pipelineAllocation);
-            request.createReadyComputePipelineCallback(status, nullptr, message, request.userdata);
+            request.createComputePipelineAsyncCallback(status, nullptr, message, request.userdata);
             return true;
         }
 
         WGPUComputePipeline pipeline = reinterpret_cast<WGPUComputePipeline>(pipelineAllocation);
-        request.createReadyComputePipelineCallback(status, pipeline, message, request.userdata);
+        request.createComputePipelineAsyncCallback(status, pipeline, message, request.userdata);
 
         return true;
     }
 
-    void Device::CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor,
-                                           WGPUCreateReadyRenderPipelineCallback callback,
+    void Device::CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
+                                           WGPUCreateRenderPipelineAsyncCallback callback,
                                            void* userdata) {
         if (client->IsDisconnected()) {
-            return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
+            return callback(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr,
                             "GPU device disconnected", userdata);
         }
-        DeviceCreateReadyRenderPipelineCmd cmd;
+        DeviceCreateRenderPipelineAsyncCmd cmd;
         cmd.deviceId = this->id;
         cmd.descriptor = descriptor;
 
-        uint64_t serial = mCreateReadyPipelineRequestSerial++;
-        ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
+        uint64_t serial = mCreatePipelineAsyncRequestSerial++;
+        ASSERT(mCreatePipelineAsyncRequests.find(serial) == mCreatePipelineAsyncRequests.end());
         cmd.requestSerial = serial;
 
         auto* allocation = client->RenderPipelineAllocator().New(client);
-        CreateReadyPipelineRequest request = {};
-        request.createReadyRenderPipelineCallback = callback;
+        CreatePipelineAsyncRequest request = {};
+        request.createRenderPipelineAsyncCallback = callback;
         request.userdata = userdata;
         request.pipelineObjectID = allocation->object->id;
 
         cmd.pipelineObjectHandle = ObjectHandle(allocation->object->id, allocation->generation);
         client->SerializeCommand(cmd);
 
-        mCreateReadyPipelineRequests[serial] = std::move(request);
+        mCreatePipelineAsyncRequests[serial] = std::move(request);
     }
 
-    bool Device::OnCreateReadyRenderPipelineCallback(uint64_t requestSerial,
-                                                     WGPUCreateReadyPipelineStatus status,
+    bool Device::OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial,
+                                                     WGPUCreatePipelineAsyncStatus status,
                                                      const char* message) {
-        const auto& requestIt = mCreateReadyPipelineRequests.find(requestSerial);
-        if (requestIt == mCreateReadyPipelineRequests.end()) {
+        const auto& requestIt = mCreatePipelineAsyncRequests.find(requestSerial);
+        if (requestIt == mCreatePipelineAsyncRequests.end()) {
             return false;
         }
 
-        CreateReadyPipelineRequest request = std::move(requestIt->second);
-        mCreateReadyPipelineRequests.erase(requestIt);
+        CreatePipelineAsyncRequest request = std::move(requestIt->second);
+        mCreatePipelineAsyncRequests.erase(requestIt);
 
         auto pipelineAllocation =
             client->RenderPipelineAllocator().GetObject(request.pipelineObjectID);
 
         // If the return status is a failure we should give a null pipeline to the callback and
         // free the allocation both on the client side and the server side.
-        if (status != WGPUCreateReadyPipelineStatus_Success) {
+        if (status != WGPUCreatePipelineAsyncStatus_Success) {
             client->RenderPipelineAllocator().Free(pipelineAllocation);
-            request.createReadyRenderPipelineCallback(status, nullptr, message, request.userdata);
+            request.createRenderPipelineAsyncCallback(status, nullptr, message, request.userdata);
             return true;
         }
 
         WGPURenderPipeline pipeline = reinterpret_cast<WGPURenderPipeline>(pipelineAllocation);
-        request.createReadyRenderPipelineCallback(status, pipeline, message, request.userdata);
+        request.createRenderPipelineAsyncCallback(status, pipeline, message, request.userdata);
 
         return true;
     }
diff --git a/src/dawn_wire/client/Device.h b/src/dawn_wire/client/Device.h
index 6e86dbe..c72200b 100644
--- a/src/dawn_wire/client/Device.h
+++ b/src/dawn_wire/client/Device.h
@@ -42,11 +42,11 @@
         bool PopErrorScope(WGPUErrorCallback callback, void* userdata);
         WGPUBuffer CreateBuffer(const WGPUBufferDescriptor* descriptor);
         WGPUBuffer CreateErrorBuffer();
-        void CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor,
-                                        WGPUCreateReadyComputePipelineCallback callback,
+        void CreateComputePipelineAsync(WGPUComputePipelineDescriptor const* descriptor,
+                                        WGPUCreateComputePipelineAsyncCallback callback,
                                         void* userdata);
-        void CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor,
-                                       WGPUCreateReadyRenderPipelineCallback callback,
+        void CreateRenderPipelineAsync(WGPURenderPipelineDescriptor const* descriptor,
+                                       WGPUCreateRenderPipelineAsyncCallback callback,
                                        void* userdata);
 
         void HandleError(WGPUErrorType errorType, const char* message);
@@ -54,11 +54,11 @@
         bool OnPopErrorScopeCallback(uint64_t requestSerial,
                                      WGPUErrorType type,
                                      const char* message);
-        bool OnCreateReadyComputePipelineCallback(uint64_t requestSerial,
-                                                  WGPUCreateReadyPipelineStatus status,
+        bool OnCreateComputePipelineAsyncCallback(uint64_t requestSerial,
+                                                  WGPUCreatePipelineAsyncStatus status,
                                                   const char* message);
-        bool OnCreateReadyRenderPipelineCallback(uint64_t requestSerial,
-                                                 WGPUCreateReadyPipelineStatus status,
+        bool OnCreateRenderPipelineAsyncCallback(uint64_t requestSerial,
+                                                 WGPUCreatePipelineAsyncStatus status,
                                                  const char* message);
 
         // TODO(dawn:22): Remove once the deprecation period is finished.
@@ -78,14 +78,14 @@
         uint64_t mErrorScopeRequestSerial = 0;
         uint64_t mErrorScopeStackSize = 0;
 
-        struct CreateReadyPipelineRequest {
-            WGPUCreateReadyComputePipelineCallback createReadyComputePipelineCallback = nullptr;
-            WGPUCreateReadyRenderPipelineCallback createReadyRenderPipelineCallback = nullptr;
+        struct CreatePipelineAsyncRequest {
+            WGPUCreateComputePipelineAsyncCallback createComputePipelineAsyncCallback = nullptr;
+            WGPUCreateRenderPipelineAsyncCallback createRenderPipelineAsyncCallback = nullptr;
             void* userdata = nullptr;
             ObjectId pipelineObjectID;
         };
-        std::map<uint64_t, CreateReadyPipelineRequest> mCreateReadyPipelineRequests;
-        uint64_t mCreateReadyPipelineRequestSerial = 0;
+        std::map<uint64_t, CreatePipelineAsyncRequest> mCreatePipelineAsyncRequests;
+        uint64_t mCreatePipelineAsyncRequestSerial = 0;
 
         WGPUErrorCallback mErrorCallback = nullptr;
         WGPUDeviceLostCallback mDeviceLostCallback = nullptr;
diff --git a/src/dawn_wire/server/Server.h b/src/dawn_wire/server/Server.h
index 90d29c4..bcedeaa 100644
--- a/src/dawn_wire/server/Server.h
+++ b/src/dawn_wire/server/Server.h
@@ -141,7 +141,7 @@
         uint64_t requestSerial;
     };
 
-    struct CreateReadyPipelineUserData : CallbackUserdata {
+    struct CreatePipelineAsyncUserData : CallbackUserdata {
         using CallbackUserdata::CallbackUserdata;
 
         ObjectHandle device;
@@ -202,14 +202,14 @@
                                           FenceCompletionUserdata* userdata);
         void OnFenceOnCompletion(WGPUFenceCompletionStatus status,
                                  FenceOnCompletionUserdata* userdata);
-        void OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status,
+        void OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                   WGPUComputePipeline pipeline,
                                                   const char* message,
-                                                  CreateReadyPipelineUserData* userdata);
-        void OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status,
+                                                  CreatePipelineAsyncUserData* userdata);
+        void OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                  WGPURenderPipeline pipeline,
                                                  const char* message,
-                                                 CreateReadyPipelineUserData* userdata);
+                                                 CreatePipelineAsyncUserData* userdata);
 
 #include "dawn_wire/server/ServerPrototypes_autogen.inc"
 
diff --git a/src/dawn_wire/server/ServerDevice.cpp b/src/dawn_wire/server/ServerDevice.cpp
index bcc8db6..19e6298 100644
--- a/src/dawn_wire/server/ServerDevice.cpp
+++ b/src/dawn_wire/server/ServerDevice.cpp
@@ -19,10 +19,10 @@
     namespace {
 
         template <ObjectType objectType, typename Pipeline>
-        void HandleCreateReadyRenderPipelineCallbackResult(KnownObjects<Pipeline>* knownObjects,
-                                                           WGPUCreateReadyPipelineStatus status,
+        void HandleCreateRenderPipelineAsyncCallbackResult(KnownObjects<Pipeline>* knownObjects,
+                                                           WGPUCreatePipelineAsyncStatus status,
                                                            Pipeline pipeline,
-                                                           CreateReadyPipelineUserData* data) {
+                                                           CreatePipelineAsyncUserData* data) {
             // May be null if the device was destroyed. Device destruction destroys child
             // objects on the wire.
             auto* pipelineObject =
@@ -31,7 +31,7 @@
             // they move from Reserved to Allocated, or if they are destroyed here.
             ASSERT(pipelineObject != nullptr);
 
-            if (status == WGPUCreateReadyPipelineStatus_Success) {
+            if (status == WGPUCreatePipelineAsyncStatus_Success) {
                 // Assign the handle and allocated status if the pipeline is created successfully.
                 pipelineObject->state = AllocationState::Allocated;
                 pipelineObject->handle = pipeline;
@@ -101,7 +101,7 @@
         SerializeCommand(cmd);
     }
 
-    bool Server::DoDeviceCreateReadyComputePipeline(
+    bool Server::DoDeviceCreateComputePipelineAsync(
         ObjectId deviceId,
         uint64_t requestSerial,
         ObjectHandle pipelineObjectHandle,
@@ -120,27 +120,27 @@
         resultData->generation = pipelineObjectHandle.generation;
         resultData->deviceInfo = device->info.get();
 
-        auto userdata = MakeUserdata<CreateReadyPipelineUserData>();
+        auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
         userdata->device = ObjectHandle{deviceId, device->generation};
         userdata->requestSerial = requestSerial;
         userdata->pipelineObjectID = pipelineObjectHandle.id;
 
-        mProcs.deviceCreateReadyComputePipeline(
+        mProcs.deviceCreateComputePipelineAsync(
             device->handle, descriptor,
-            ForwardToServer<decltype(&Server::OnCreateReadyComputePipelineCallback)>::Func<
-                &Server::OnCreateReadyComputePipelineCallback>(),
+            ForwardToServer<decltype(&Server::OnCreateComputePipelineAsyncCallback)>::Func<
+                &Server::OnCreateComputePipelineAsyncCallback>(),
             userdata.release());
         return true;
     }
 
-    void Server::OnCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status,
+    void Server::OnCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                       WGPUComputePipeline pipeline,
                                                       const char* message,
-                                                      CreateReadyPipelineUserData* data) {
-        HandleCreateReadyRenderPipelineCallbackResult<ObjectType::ComputePipeline>(
+                                                      CreatePipelineAsyncUserData* data) {
+        HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::ComputePipeline>(
             &ComputePipelineObjects(), status, pipeline, data);
 
-        ReturnDeviceCreateReadyComputePipelineCallbackCmd cmd;
+        ReturnDeviceCreateComputePipelineAsyncCallbackCmd cmd;
         cmd.device = data->device;
         cmd.status = status;
         cmd.requestSerial = data->requestSerial;
@@ -149,7 +149,7 @@
         SerializeCommand(cmd);
     }
 
-    bool Server::DoDeviceCreateReadyRenderPipeline(ObjectId deviceId,
+    bool Server::DoDeviceCreateRenderPipelineAsync(ObjectId deviceId,
                                                    uint64_t requestSerial,
                                                    ObjectHandle pipelineObjectHandle,
                                                    const WGPURenderPipelineDescriptor* descriptor) {
@@ -167,27 +167,27 @@
         resultData->generation = pipelineObjectHandle.generation;
         resultData->deviceInfo = device->info.get();
 
-        auto userdata = MakeUserdata<CreateReadyPipelineUserData>();
+        auto userdata = MakeUserdata<CreatePipelineAsyncUserData>();
         userdata->device = ObjectHandle{deviceId, device->generation};
         userdata->requestSerial = requestSerial;
         userdata->pipelineObjectID = pipelineObjectHandle.id;
 
-        mProcs.deviceCreateReadyRenderPipeline(
+        mProcs.deviceCreateRenderPipelineAsync(
             device->handle, descriptor,
-            ForwardToServer<decltype(&Server::OnCreateReadyRenderPipelineCallback)>::Func<
-                &Server::OnCreateReadyRenderPipelineCallback>(),
+            ForwardToServer<decltype(&Server::OnCreateRenderPipelineAsyncCallback)>::Func<
+                &Server::OnCreateRenderPipelineAsyncCallback>(),
             userdata.release());
         return true;
     }
 
-    void Server::OnCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status,
+    void Server::OnCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                      WGPURenderPipeline pipeline,
                                                      const char* message,
-                                                     CreateReadyPipelineUserData* data) {
-        HandleCreateReadyRenderPipelineCallbackResult<ObjectType::RenderPipeline>(
+                                                     CreatePipelineAsyncUserData* data) {
+        HandleCreateRenderPipelineAsyncCallbackResult<ObjectType::RenderPipeline>(
             &RenderPipelineObjects(), status, pipeline, data);
 
-        ReturnDeviceCreateReadyRenderPipelineCallbackCmd cmd;
+        ReturnDeviceCreateRenderPipelineAsyncCallbackCmd cmd;
         cmd.device = data->device;
         cmd.status = status;
         cmd.requestSerial = data->requestSerial;
diff --git a/src/tests/BUILD.gn b/src/tests/BUILD.gn
index efc2aee..0c3ffc3 100644
--- a/src/tests/BUILD.gn
+++ b/src/tests/BUILD.gn
@@ -221,7 +221,7 @@
     "unittests/wire/WireArgumentTests.cpp",
     "unittests/wire/WireBasicTests.cpp",
     "unittests/wire/WireBufferMappingTests.cpp",
-    "unittests/wire/WireCreateReadyPipelineTests.cpp",
+    "unittests/wire/WireCreatePipelineAsyncTests.cpp",
     "unittests/wire/WireDestroyObjectTests.cpp",
     "unittests/wire/WireDisconnectTests.cpp",
     "unittests/wire/WireErrorCallbackTests.cpp",
@@ -283,7 +283,7 @@
     "end2end/ComputeStorageBufferBarrierTests.cpp",
     "end2end/CopyTests.cpp",
     "end2end/CopyTextureForBrowserTests.cpp",
-    "end2end/CreateReadyPipelineTests.cpp",
+    "end2end/CreatePipelineAsyncTests.cpp",
     "end2end/CullingTests.cpp",
     "end2end/DebugMarkerTests.cpp",
     "end2end/DeprecatedAPITests.cpp",
diff --git a/src/tests/end2end/CreateReadyPipelineTests.cpp b/src/tests/end2end/CreatePipelineAsyncTests.cpp
similarity index 77%
rename from src/tests/end2end/CreateReadyPipelineTests.cpp
rename to src/tests/end2end/CreatePipelineAsyncTests.cpp
index a10d208..ef6307c 100644
--- a/src/tests/end2end/CreateReadyPipelineTests.cpp
+++ b/src/tests/end2end/CreatePipelineAsyncTests.cpp
@@ -18,7 +18,7 @@
 #include "utils/WGPUHelpers.h"
 
 namespace {
-    struct CreateReadyPipelineTask {
+    struct CreatePipelineAsyncTask {
         wgpu::ComputePipeline computePipeline = nullptr;
         wgpu::RenderPipeline renderPipeline = nullptr;
         bool isCompleted = false;
@@ -26,13 +26,13 @@
     };
 }  // anonymous namespace
 
-class CreateReadyPipelineTest : public DawnTest {
+class CreatePipelineAsyncTest : public DawnTest {
   protected:
-    CreateReadyPipelineTask task;
+    CreatePipelineAsyncTask task;
 };
 
-// Verify the basic use of CreateReadyComputePipeline works on all backends.
-TEST_P(CreateReadyPipelineTest, BasicUseOfCreateReadyComputePipeline) {
+// Verify the basic use of CreateComputePipelineAsync works on all backends.
+TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateComputePipelineAsync) {
     wgpu::ComputePipelineDescriptor csDesc;
     csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"(
         [[block]] struct SSBO {
@@ -45,13 +45,13 @@
         })");
     csDesc.computeStage.entryPoint = "main";
 
-    device.CreateReadyComputePipeline(
+    device.CreateComputePipelineAsync(
         &csDesc,
-        [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Success, status);
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -93,11 +93,11 @@
     EXPECT_BUFFER_U32_EQ(kExpected, ssbo, 0);
 }
 
-// Verify CreateReadyComputePipeline() works as expected when there is any error that happens during
+// Verify CreateComputePipelineAsync() works as expected when there is any error that happens during
 // the creation of the compute pipeline. The SPEC requires that during the call of
-// CreateReadyComputePipeline() any error won't be forwarded to the error scope / unhandled error
+// CreateComputePipelineAsync() any error won't be forwarded to the error scope / unhandled error
 // callback.
-TEST_P(CreateReadyPipelineTest, CreateComputePipelineFailed) {
+TEST_P(CreatePipelineAsyncTest, CreateComputePipelineFailed) {
     DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation"));
 
     wgpu::ComputePipelineDescriptor csDesc;
@@ -112,13 +112,13 @@
         })");
     csDesc.computeStage.entryPoint = "main0";
 
-    device.CreateReadyComputePipeline(
+    device.CreateComputePipelineAsync(
         &csDesc,
-        [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Error, status);
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -133,8 +133,8 @@
     ASSERT_EQ(nullptr, task.computePipeline.Get());
 }
 
-// Verify the basic use of CreateReadyRenderPipeline() works on all backends.
-TEST_P(CreateReadyPipelineTest, BasicUseOfCreateReadyRenderPipeline) {
+// Verify the basic use of CreateRenderPipelineAsync() works on all backends.
+TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateRenderPipelineAsync) {
     constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm;
 
     utils::ComboRenderPipelineDescriptor renderPipelineDescriptor(device);
@@ -153,13 +153,13 @@
     renderPipelineDescriptor.cColorStates[0].format = kRenderAttachmentFormat;
     renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList;
 
-    device.CreateReadyRenderPipeline(
+    device.CreateRenderPipelineAsync(
         &renderPipelineDescriptor,
-        [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Success, status);
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Success, status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -198,11 +198,11 @@
     EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), outputTexture, 0, 0);
 }
 
-// Verify CreateReadyRenderPipeline() works as expected when there is any error that happens during
+// Verify CreateRenderPipelineAsync() works as expected when there is any error that happens during
 // the creation of the render pipeline. The SPEC requires that during the call of
-// CreateReadyRenderPipeline() any error won't be forwarded to the error scope / unhandled error
+// CreateRenderPipelineAsync() any error won't be forwarded to the error scope / unhandled error
 // callback.
-TEST_P(CreateReadyPipelineTest, CreateRenderPipelineFailed) {
+TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineFailed) {
     DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation"));
 
     constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::Depth32Float;
@@ -223,13 +223,13 @@
     renderPipelineDescriptor.cColorStates[0].format = kRenderAttachmentFormat;
     renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList;
 
-    device.CreateReadyRenderPipeline(
+    device.CreateRenderPipelineAsync(
         &renderPipelineDescriptor,
-        [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_Error, status);
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_Error, status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -245,22 +245,22 @@
 }
 
 // Verify there is no error when the device is released before the callback of
-// CreateReadyComputePipeline() is called.
-TEST_P(CreateReadyPipelineTest, ReleaseDeviceBeforeCallbackOfCreateReadyComputePipeline) {
+// CreateComputePipelineAsync() is called.
+TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipelineAsync) {
     wgpu::ComputePipelineDescriptor csDesc;
     csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"(
         [[stage(compute)]] fn main() -> void {
         })");
     csDesc.computeStage.entryPoint = "main";
 
-    device.CreateReadyComputePipeline(
+    device.CreateComputePipelineAsync(
         &csDesc,
-        [](WGPUCreateReadyPipelineStatus status, WGPUComputePipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPUComputePipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_DeviceDestroyed,
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed,
                       status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->computePipeline = wgpu::ComputePipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -269,8 +269,8 @@
 }
 
 // Verify there is no error when the device is released before the callback of
-// CreateReadyRenderPipeline() is called.
-TEST_P(CreateReadyPipelineTest, ReleaseDeviceBeforeCallbackOfCreateReadyRenderPipeline) {
+// CreateRenderPipelineAsync() is called.
+TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateRenderPipelineAsync) {
     utils::ComboRenderPipelineDescriptor renderPipelineDescriptor(device);
     wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"(
         [[builtin(position)]] var<out> Position : vec4<f32>;
@@ -287,14 +287,14 @@
     renderPipelineDescriptor.cColorStates[0].format = wgpu::TextureFormat::RGBA8Unorm;
     renderPipelineDescriptor.primitiveTopology = wgpu::PrimitiveTopology::PointList;
 
-    device.CreateReadyRenderPipeline(
+    device.CreateRenderPipelineAsync(
         &renderPipelineDescriptor,
-        [](WGPUCreateReadyPipelineStatus status, WGPURenderPipeline returnPipeline,
+        [](WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline returnPipeline,
            const char* message, void* userdata) {
-            EXPECT_EQ(WGPUCreateReadyPipelineStatus::WGPUCreateReadyPipelineStatus_DeviceDestroyed,
+            EXPECT_EQ(WGPUCreatePipelineAsyncStatus::WGPUCreatePipelineAsyncStatus_DeviceDestroyed,
                       status);
 
-            CreateReadyPipelineTask* task = static_cast<CreateReadyPipelineTask*>(userdata);
+            CreatePipelineAsyncTask* task = static_cast<CreatePipelineAsyncTask*>(userdata);
             task->renderPipeline = wgpu::RenderPipeline::Acquire(returnPipeline);
             task->isCompleted = true;
             task->message = message;
@@ -302,7 +302,7 @@
         &task);
 }
 
-DAWN_INSTANTIATE_TEST(CreateReadyPipelineTest,
+DAWN_INSTANTIATE_TEST(CreatePipelineAsyncTest,
                       D3D12Backend(),
                       MetalBackend(),
                       OpenGLBackend(),
diff --git a/src/tests/unittests/WorkerThreadTests.cpp b/src/tests/unittests/WorkerThreadTests.cpp
index 8faee5d..996d7e1 100644
--- a/src/tests/unittests/WorkerThreadTests.cpp
+++ b/src/tests/unittests/WorkerThreadTests.cpp
@@ -149,7 +149,7 @@
 
 class WorkerThreadTest : public testing::Test {};
 
-// Emulate the basic usage of worker thread pool in CreateReady*Pipeline().
+// Emulate the basic usage of worker thread pool in Create*PipelineAsync().
 TEST_F(WorkerThreadTest, Basic) {
     dawn_platform::Platform platform;
     std::unique_ptr<dawn_platform::WorkerTaskPool> pool = platform.CreateWorkerTaskPool();
diff --git a/src/tests/unittests/validation/MultipleDeviceTests.cpp b/src/tests/unittests/validation/MultipleDeviceTests.cpp
index 1d1dee2..0f940b0 100644
--- a/src/tests/unittests/validation/MultipleDeviceTests.cpp
+++ b/src/tests/unittests/validation/MultipleDeviceTests.cpp
@@ -28,9 +28,9 @@
     ASSERT_DEVICE_ERROR(device.GetQueue().Submit(1, &commandBuffer));
 }
 
-// Test that CreateReadyPipeline fails creation with an Error status if it uses
+// Test that CreatePipelineAsync fails creation with an Error status if it uses
 // objects from a different device.
-TEST_F(MultipleDeviceTest, ValidatesSameDeviceCreateReadyPipeline) {
+TEST_F(MultipleDeviceTest, ValidatesSameDeviceCreatePipelineAsync) {
     wgpu::ShaderModuleWGSLDescriptor wgslDesc = {};
     wgslDesc.source = R"(
         [[stage(compute)]] fn main() -> void {
@@ -40,7 +40,7 @@
     wgpu::ShaderModuleDescriptor shaderModuleDesc = {};
     shaderModuleDesc.nextInChain = &wgslDesc;
 
-    // Base case: CreateReadyComputePipeline succeeds.
+    // Base case: CreateComputePipelineAsync succeeds.
     {
         wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc);
 
@@ -48,18 +48,18 @@
         pipelineDesc.computeStage.module = shaderModule;
         pipelineDesc.computeStage.entryPoint = "main";
 
-        StrictMock<MockCallback<WGPUCreateReadyComputePipelineCallback>> creationCallback;
+        StrictMock<MockCallback<WGPUCreateComputePipelineAsyncCallback>> creationCallback;
         EXPECT_CALL(creationCallback,
-                    Call(WGPUCreateReadyPipelineStatus_Success, NotNull(), _, this))
+                    Call(WGPUCreatePipelineAsyncStatus_Success, NotNull(), _, this))
             .WillOnce(WithArg<1>(Invoke(
                 [](WGPUComputePipeline pipeline) { wgpu::ComputePipeline::Acquire(pipeline); })));
-        device.CreateReadyComputePipeline(&pipelineDesc, creationCallback.Callback(),
+        device.CreateComputePipelineAsync(&pipelineDesc, creationCallback.Callback(),
                                           creationCallback.MakeUserdata(this));
 
         WaitForAllOperations(device);
     }
 
-    // CreateReadyComputePipeline errors if the shader module is created on a different device.
+    // CreateComputePipelineAsync errors if the shader module is created on a different device.
     {
         wgpu::Device device2 = RegisterDevice(CreateTestDevice());
         wgpu::ShaderModule shaderModule = device2.CreateShaderModule(&shaderModuleDesc);
@@ -68,11 +68,11 @@
         pipelineDesc.computeStage.module = shaderModule;
         pipelineDesc.computeStage.entryPoint = "main";
 
-        StrictMock<MockCallback<WGPUCreateReadyComputePipelineCallback>> creationCallback;
+        StrictMock<MockCallback<WGPUCreateComputePipelineAsyncCallback>> creationCallback;
         EXPECT_CALL(creationCallback,
-                    Call(WGPUCreateReadyPipelineStatus_Error, nullptr, _, this + 1))
+                    Call(WGPUCreatePipelineAsyncStatus_Error, nullptr, _, this + 1))
             .Times(1);
-        device.CreateReadyComputePipeline(&pipelineDesc, creationCallback.Callback(),
+        device.CreateComputePipelineAsync(&pipelineDesc, creationCallback.Callback(),
                                           creationCallback.MakeUserdata(this + 1));
 
         WaitForAllOperations(device);
diff --git a/src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp b/src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
similarity index 61%
rename from src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp
rename to src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
index 2e7ae0f..72cdc94 100644
--- a/src/tests/unittests/wire/WireCreateReadyPipelineTests.cpp
+++ b/src/tests/unittests/wire/WireCreatePipelineAsyncTests.cpp
@@ -22,78 +22,78 @@
 namespace {
 
     // Mock class to add expectations on the wire calling callbacks
-    class MockCreateReadyComputePipelineCallback {
+    class MockCreateComputePipelineAsyncCallback {
       public:
         MOCK_METHOD(void,
                     Call,
-                    (WGPUCreateReadyPipelineStatus status,
+                    (WGPUCreatePipelineAsyncStatus status,
                      WGPUComputePipeline pipeline,
                      const char* message,
                      void* userdata));
     };
 
-    std::unique_ptr<StrictMock<MockCreateReadyComputePipelineCallback>>
-        mockCreateReadyComputePipelineCallback;
-    void ToMockCreateReadyComputePipelineCallback(WGPUCreateReadyPipelineStatus status,
+    std::unique_ptr<StrictMock<MockCreateComputePipelineAsyncCallback>>
+        mockCreateComputePipelineAsyncCallback;
+    void ToMockCreateComputePipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                   WGPUComputePipeline pipeline,
                                                   const char* message,
                                                   void* userdata) {
-        mockCreateReadyComputePipelineCallback->Call(status, pipeline, message, userdata);
+        mockCreateComputePipelineAsyncCallback->Call(status, pipeline, message, userdata);
     }
 
-    class MockCreateReadyRenderPipelineCallback {
+    class MockCreateRenderPipelineAsyncCallback {
       public:
         MOCK_METHOD(void,
                     Call,
-                    (WGPUCreateReadyPipelineStatus status,
+                    (WGPUCreatePipelineAsyncStatus status,
                      WGPURenderPipeline pipeline,
                      const char* message,
                      void* userdata));
     };
 
-    std::unique_ptr<StrictMock<MockCreateReadyRenderPipelineCallback>>
-        mockCreateReadyRenderPipelineCallback;
-    void ToMockCreateReadyRenderPipelineCallback(WGPUCreateReadyPipelineStatus status,
+    std::unique_ptr<StrictMock<MockCreateRenderPipelineAsyncCallback>>
+        mockCreateRenderPipelineAsyncCallback;
+    void ToMockCreateRenderPipelineAsyncCallback(WGPUCreatePipelineAsyncStatus status,
                                                  WGPURenderPipeline pipeline,
                                                  const char* message,
                                                  void* userdata) {
-        mockCreateReadyRenderPipelineCallback->Call(status, pipeline, message, userdata);
+        mockCreateRenderPipelineAsyncCallback->Call(status, pipeline, message, userdata);
     }
 
 }  // anonymous namespace
 
-class WireCreateReadyPipelineTest : public WireTest {
+class WireCreatePipelineAsyncTest : public WireTest {
   public:
     void SetUp() override {
         WireTest::SetUp();
 
-        mockCreateReadyComputePipelineCallback =
-            std::make_unique<StrictMock<MockCreateReadyComputePipelineCallback>>();
-        mockCreateReadyRenderPipelineCallback =
-            std::make_unique<StrictMock<MockCreateReadyRenderPipelineCallback>>();
+        mockCreateComputePipelineAsyncCallback =
+            std::make_unique<StrictMock<MockCreateComputePipelineAsyncCallback>>();
+        mockCreateRenderPipelineAsyncCallback =
+            std::make_unique<StrictMock<MockCreateRenderPipelineAsyncCallback>>();
     }
 
     void TearDown() override {
         WireTest::TearDown();
 
         // Delete mock so that expectations are checked
-        mockCreateReadyComputePipelineCallback = nullptr;
-        mockCreateReadyRenderPipelineCallback = nullptr;
+        mockCreateComputePipelineAsyncCallback = nullptr;
+        mockCreateRenderPipelineAsyncCallback = nullptr;
     }
 
     void FlushClient() {
         WireTest::FlushClient();
-        Mock::VerifyAndClearExpectations(&mockCreateReadyComputePipelineCallback);
+        Mock::VerifyAndClearExpectations(&mockCreateComputePipelineAsyncCallback);
     }
 
     void FlushServer() {
         WireTest::FlushServer();
-        Mock::VerifyAndClearExpectations(&mockCreateReadyComputePipelineCallback);
+        Mock::VerifyAndClearExpectations(&mockCreateComputePipelineAsyncCallback);
     }
 };
 
-// Test when creating a compute pipeline with CreateReadyComputePipeline() successfully.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineSuccess) {
+// Test when creating a compute pipeline with CreateComputePipelineAsync() successfully.
+TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncSuccess) {
     WGPUShaderModuleDescriptor csDescriptor{};
     WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor);
     WGPUShaderModule apiCsModule = api.GetNewShaderModule();
@@ -103,26 +103,26 @@
     descriptor.computeStage.module = csModule;
     descriptor.computeStage.entryPoint = "main";
 
-    wgpuDeviceCreateReadyComputePipeline(device, &descriptor,
-                                         ToMockCreateReadyComputePipelineCallback, this);
+    wgpuDeviceCreateComputePipelineAsync(device, &descriptor,
+                                         ToMockCreateComputePipelineAsyncCallback, this);
 
-    EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _))
+    EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyComputePipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, "");
+            api.CallDeviceCreateComputePipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyComputePipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_Success, _, StrEq(""), this))
+    EXPECT_CALL(*mockCreateComputePipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_Success, _, StrEq(""), this))
         .Times(1);
 
     FlushServer();
 }
 
-// Test when creating a compute pipeline with CreateReadyComputePipeline() results in an error.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineError) {
+// Test when creating a compute pipeline with CreateComputePipelineAsync() results in an error.
+TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncError) {
     WGPUShaderModuleDescriptor csDescriptor{};
     WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor);
     WGPUShaderModule apiCsModule = api.GetNewShaderModule();
@@ -132,26 +132,26 @@
     descriptor.computeStage.module = csModule;
     descriptor.computeStage.entryPoint = "main";
 
-    wgpuDeviceCreateReadyComputePipeline(device, &descriptor,
-                                         ToMockCreateReadyComputePipelineCallback, this);
+    wgpuDeviceCreateComputePipelineAsync(device, &descriptor,
+                                         ToMockCreateComputePipelineAsyncCallback, this);
 
-    EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _))
+    EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyComputePipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Error, nullptr, "Some error message");
+            api.CallDeviceCreateComputePipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Error, nullptr, "Some error message");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyComputePipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_Error, _, StrEq("Some error message"), this))
+    EXPECT_CALL(*mockCreateComputePipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_Error, _, StrEq("Some error message"), this))
         .Times(1);
 
     FlushServer();
 }
 
-// Test when creating a render pipeline with CreateReadyRenderPipeline() successfully.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineSuccess) {
+// Test when creating a render pipeline with CreateRenderPipelineAsync() successfully.
+TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncSuccess) {
     WGPUShaderModuleDescriptor vertexDescriptor = {};
     WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
     WGPUShaderModule apiVsModule = api.GetNewShaderModule();
@@ -166,25 +166,25 @@
     fragmentStage.entryPoint = "main";
     pipelineDescriptor.fragmentStage = &fragmentStage;
 
-    wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor,
-                                        ToMockCreateReadyRenderPipelineCallback, this);
-    EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _))
+    wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor,
+                                        ToMockCreateRenderPipelineAsyncCallback, this);
+    EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyRenderPipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, "");
+            api.CallDeviceCreateRenderPipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyRenderPipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_Success, _, StrEq(""), this))
+    EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_Success, _, StrEq(""), this))
         .Times(1);
 
     FlushServer();
 }
 
-// Test when creating a render pipeline with CreateReadyRenderPipeline() results in an error.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineError) {
+// Test when creating a render pipeline with CreateRenderPipelineAsync() results in an error.
+TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncError) {
     WGPUShaderModuleDescriptor vertexDescriptor = {};
     WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
     WGPUShaderModule apiVsModule = api.GetNewShaderModule();
@@ -199,18 +199,18 @@
     fragmentStage.entryPoint = "main";
     pipelineDescriptor.fragmentStage = &fragmentStage;
 
-    wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor,
-                                        ToMockCreateReadyRenderPipelineCallback, this);
-    EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _))
+    wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor,
+                                        ToMockCreateRenderPipelineAsyncCallback, this);
+    EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyRenderPipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Error, nullptr, "Some error message");
+            api.CallDeviceCreateRenderPipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Error, nullptr, "Some error message");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyRenderPipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_Error, _, StrEq("Some error message"), this))
+    EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_Error, _, StrEq("Some error message"), this))
         .Times(1);
 
     FlushServer();
@@ -218,7 +218,7 @@
 
 // Test that registering a callback then wire disconnect calls the callback with
 // DeviceLost.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineThenDisconnect) {
+TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncThenDisconnect) {
     WGPUShaderModuleDescriptor vertexDescriptor = {};
     WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
     WGPUShaderModule apiVsModule = api.GetNewShaderModule();
@@ -233,25 +233,25 @@
     pipelineDescriptor.vertexStage.entryPoint = "main";
     pipelineDescriptor.fragmentStage = &fragmentStage;
 
-    wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor,
-                                        ToMockCreateReadyRenderPipelineCallback, this);
-    EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _))
+    wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor,
+                                        ToMockCreateRenderPipelineAsyncCallback, this);
+    EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyRenderPipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, "");
+            api.CallDeviceCreateRenderPipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyRenderPipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_DeviceLost, _, _, this))
+    EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_DeviceLost, _, _, this))
         .Times(1);
     GetWireClient()->Disconnect();
 }
 
 // Test that registering a callback then wire disconnect calls the callback with
 // DeviceLost.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineThenDisconnect) {
+TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncThenDisconnect) {
     WGPUShaderModuleDescriptor csDescriptor{};
     WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor);
     WGPUShaderModule apiCsModule = api.GetNewShaderModule();
@@ -261,25 +261,25 @@
     descriptor.computeStage.module = csModule;
     descriptor.computeStage.entryPoint = "main";
 
-    wgpuDeviceCreateReadyComputePipeline(device, &descriptor,
-                                         ToMockCreateReadyComputePipelineCallback, this);
-    EXPECT_CALL(api, OnDeviceCreateReadyComputePipeline(apiDevice, _, _, _))
+    wgpuDeviceCreateComputePipelineAsync(device, &descriptor,
+                                         ToMockCreateComputePipelineAsyncCallback, this);
+    EXPECT_CALL(api, OnDeviceCreateComputePipelineAsync(apiDevice, _, _, _))
         .WillOnce(InvokeWithoutArgs([&]() {
-            api.CallDeviceCreateReadyComputePipelineCallback(
-                apiDevice, WGPUCreateReadyPipelineStatus_Success, nullptr, "");
+            api.CallDeviceCreateComputePipelineAsyncCallback(
+                apiDevice, WGPUCreatePipelineAsyncStatus_Success, nullptr, "");
         }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyComputePipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_DeviceLost, _, _, this))
+    EXPECT_CALL(*mockCreateComputePipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_DeviceLost, _, _, this))
         .Times(1);
     GetWireClient()->Disconnect();
 }
 
 // Test that registering a callback after wire disconnect calls the callback with
 // DeviceLost.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyRenderPipelineAfterDisconnect) {
+TEST_F(WireCreatePipelineAsyncTest, CreateRenderPipelineAsyncAfterDisconnect) {
     WGPUShaderModuleDescriptor vertexDescriptor = {};
     WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
     WGPUShaderModule apiVsModule = api.GetNewShaderModule();
@@ -298,16 +298,16 @@
 
     GetWireClient()->Disconnect();
 
-    EXPECT_CALL(*mockCreateReadyRenderPipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, _, this))
+    EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, _, this))
         .Times(1);
-    wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor,
-                                        ToMockCreateReadyRenderPipelineCallback, this);
+    wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor,
+                                        ToMockCreateRenderPipelineAsyncCallback, this);
 }
 
 // Test that registering a callback after wire disconnect calls the callback with
 // DeviceLost.
-TEST_F(WireCreateReadyPipelineTest, CreateReadyComputePipelineAfterDisconnect) {
+TEST_F(WireCreatePipelineAsyncTest, CreateComputePipelineAsyncAfterDisconnect) {
     WGPUShaderModuleDescriptor csDescriptor{};
     WGPUShaderModule csModule = wgpuDeviceCreateShaderModule(device, &csDescriptor);
     WGPUShaderModule apiCsModule = api.GetNewShaderModule();
@@ -321,15 +321,15 @@
 
     GetWireClient()->Disconnect();
 
-    EXPECT_CALL(*mockCreateReadyComputePipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr, _, this))
+    EXPECT_CALL(*mockCreateComputePipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_DeviceLost, nullptr, _, this))
         .Times(1);
 
-    wgpuDeviceCreateReadyComputePipeline(device, &descriptor,
-                                         ToMockCreateReadyComputePipelineCallback, this);
+    wgpuDeviceCreateComputePipelineAsync(device, &descriptor,
+                                         ToMockCreateComputePipelineAsyncCallback, this);
 }
 
-TEST_F(WireCreateReadyPipelineTest, DeviceDeletedBeforeCallback) {
+TEST_F(WireCreatePipelineAsyncTest, DeviceDeletedBeforeCallback) {
     WGPUShaderModuleDescriptor vertexDescriptor = {};
     WGPUShaderModule module = wgpuDeviceCreateShaderModule(device, &vertexDescriptor);
     WGPUShaderModule apiModule = api.GetNewShaderModule();
@@ -344,14 +344,14 @@
     fragmentStage.entryPoint = "main";
     pipelineDescriptor.fragmentStage = &fragmentStage;
 
-    wgpuDeviceCreateReadyRenderPipeline(device, &pipelineDescriptor,
-                                        ToMockCreateReadyRenderPipelineCallback, this);
+    wgpuDeviceCreateRenderPipelineAsync(device, &pipelineDescriptor,
+                                        ToMockCreateRenderPipelineAsyncCallback, this);
 
-    EXPECT_CALL(api, OnDeviceCreateReadyRenderPipeline(apiDevice, _, _, _));
+    EXPECT_CALL(api, OnDeviceCreateRenderPipelineAsync(apiDevice, _, _, _));
     FlushClient();
 
-    EXPECT_CALL(*mockCreateReadyRenderPipelineCallback,
-                Call(WGPUCreateReadyPipelineStatus_DeviceDestroyed, nullptr, _, this))
+    EXPECT_CALL(*mockCreateRenderPipelineAsyncCallback,
+                Call(WGPUCreatePipelineAsyncStatus_DeviceDestroyed, nullptr, _, this))
         .Times(1);
 
     wgpuDeviceRelease(device);