diff --git a/src/dawn/fuzzers/lpmfuzz/DawnLPMFuzzer.cpp b/src/dawn/fuzzers/lpmfuzz/DawnLPMFuzzer.cpp
index 682f4e7..a524c25 100644
--- a/src/dawn/fuzzers/lpmfuzz/DawnLPMFuzzer.cpp
+++ b/src/dawn/fuzzers/lpmfuzz/DawnLPMFuzzer.cpp
@@ -64,9 +64,9 @@
 int Initialize(int* argc, char*** argv) {
     // TODO(crbug.com/1038952): The Instance must be static because destructing the vkInstance with
     // Swiftshader crashes libFuzzer. When this is fixed, move this into Run so that error injection
-    // for adapter discovery can be fuzzed.
+    // for physical device discovery can be fuzzed.
     sInstance = std::make_unique<dawn::native::Instance>();
-    sInstance->DiscoverDefaultAdapters();
+    sInstance->DiscoverDefaultPhysicalDevices();
 
     return 0;
 }
diff --git a/src/dawn/node/binding/GPU.cpp b/src/dawn/node/binding/GPU.cpp
index 71153b8..e858213 100644
--- a/src/dawn/node/binding/GPU.cpp
+++ b/src/dawn/node/binding/GPU.cpp
@@ -105,7 +105,7 @@
     if (auto dir = flags_.Get("dlldir")) {
         SetDllDir(dir->c_str());
     }
-    instance_.DiscoverDefaultAdapters();
+    instance_.DiscoverDefaultPhysicalDevices();
 }
 
 interop::Promise<std::optional<interop::Interface<interop::GPUAdapter>>> GPU::requestAdapter(
diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp
index 30bb0f5..aa0c53b 100644
--- a/src/dawn/tests/DawnTest.cpp
+++ b/src/dawn/tests/DawnTest.cpp
@@ -185,7 +185,7 @@
     // because the Vulkan validation layers use static global mutexes which behave badly when
     // Chromium's test launcher forks the test process. The instance will be recreated on test
     // environment setup.
-    std::unique_ptr<dawn::native::Instance> instance = CreateInstanceAndDiscoverAdapters();
+    std::unique_ptr<dawn::native::Instance> instance = CreateInstanceAndDiscoverPhysicalDevices();
     ASSERT(instance);
 
     if (!ValidateToggles(instance.get())) {
@@ -377,8 +377,8 @@
     }
 }
 
-std::unique_ptr<dawn::native::Instance> DawnTestEnvironment::CreateInstanceAndDiscoverAdapters(
-    dawn::platform::Platform* platform) {
+std::unique_ptr<dawn::native::Instance>
+DawnTestEnvironment::CreateInstanceAndDiscoverPhysicalDevices(dawn::platform::Platform* platform) {
     // Create an instance with toggle AllowUnsafeAPIs enabled, which would be inherited to
     // adapter and device toggles and allow us to test unsafe apis (including experimental
     // features).
@@ -623,7 +623,7 @@
 }
 
 void DawnTestEnvironment::SetUp() {
-    mInstance = CreateInstanceAndDiscoverAdapters();
+    mInstance = CreateInstanceAndDiscoverPhysicalDevices();
     ASSERT(mInstance);
 }
 
diff --git a/src/dawn/tests/DawnTest.h b/src/dawn/tests/DawnTest.h
index c10284e..f618a1c 100644
--- a/src/dawn/tests/DawnTest.h
+++ b/src/dawn/tests/DawnTest.h
@@ -183,7 +183,7 @@
     bool RunSuppressedTests() const;
 
   protected:
-    std::unique_ptr<dawn::native::Instance> CreateInstanceAndDiscoverAdapters(
+    std::unique_ptr<dawn::native::Instance> CreateInstanceAndDiscoverPhysicalDevices(
         dawn::platform::Platform* platform = nullptr);
     std::unique_ptr<dawn::native::Instance> mInstance;
 
diff --git a/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp b/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
index def6f22..63803dd 100644
--- a/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
+++ b/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
@@ -87,7 +87,7 @@
         IsDP4aSupportedOnAdapter() &&
         // Proper toggle, allow_unsafe_apis and use_dxc if d3d12
         // Note that "allow_unsafe_apis" is always enabled in
-        // DawnTestEnvironment::CreateInstanceAndDiscoverAdapters.
+        // DawnTestEnvironment::CreateInstanceAndDiscoverPhysicalDevices.
         HasToggleEnabled("allow_unsafe_apis") && UseDxcEnabledOrNonD3D12();
     const bool deviceSupportDP4AFeature =
         device.HasFeature(wgpu::FeatureName::ChromiumExperimentalDp4a);
diff --git a/src/dawn/tests/perf_tests/DawnPerfTest.cpp b/src/dawn/tests/perf_tests/DawnPerfTest.cpp
index 521cbf8..907817c 100644
--- a/src/dawn/tests/perf_tests/DawnPerfTest.cpp
+++ b/src/dawn/tests/perf_tests/DawnPerfTest.cpp
@@ -123,7 +123,7 @@
 
 void DawnPerfTestEnvironment::SetUp() {
     mPlatform = std::make_unique<DawnPerfTestPlatform>();
-    mInstance = CreateInstanceAndDiscoverAdapters(mPlatform.get());
+    mInstance = CreateInstanceAndDiscoverPhysicalDevices(mPlatform.get());
     ASSERT(mInstance);
 
     // Begin writing the trace event array.
