Change std::find() to use base:: functions: gpu/

Simplifies code slightly.

Bug: 1368812
Change-Id: I17971cc782478419bec924854a16eafaed74f4cc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3928121
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1052791}

gpu/command_buffer/service/shared_image/shared_image_backing.cc

@@ -5,6 +5,7 @@
 #include "gpu/command_buffer/service/shared_image/shared_image_backing.h"
 
 #include "base/notreached.h"
+#include "base/ranges/algorithm.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
 #include "components/viz/common/resources/resource_format_utils.h"
@@ -218,7 +219,7 @@ void SharedImageBacking::ReleaseRef(SharedImageRepresentation* representation) {
   AutoLock auto_lock(this);
   DCHECK(is_ref_counted_);
 
-  auto found = std::find(refs_.begin(), refs_.end(), representation);
+  auto found = base::ranges::find(refs_, representation);
   DCHECK(found != refs_.end());
 
   // If the found representation is the first (owning) ref, free the attributed

gpu/command_buffer/service/value_validator.h

@@ -7,9 +7,11 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_VALUE_VALIDATOR_H_
 #define GPU_COMMAND_BUFFER_SERVICE_VALUE_VALIDATOR_H_
 
-#include <algorithm>
 #include <vector>
 
+#include "base/containers/contains.h"
+#include "base/ranges/algorithm.h"
+
 namespace gpu {
 
 // ValueValidator returns true if a value is valid.
@@ -36,8 +38,7 @@ class ValueValidator {
 
   void RemoveValues(const T* invalid_values, int num_values) {
     for (int ii = 0; ii < num_values; ++ii) {
-      auto iter = std::find(valid_values_.begin(), valid_values_.end(),
-                            invalid_values[ii]);
+      auto iter = base::ranges::find(valid_values_, invalid_values[ii]);
       if (iter != valid_values_.end()) {
         valid_values_.erase(iter);
         DCHECK(!IsValid(invalid_values[ii]));
@@ -46,8 +47,7 @@ class ValueValidator {
   }
 
   bool IsValid(const T value) const {
-    return std::find(valid_values_.begin(), valid_values_.end(), value) !=
-           valid_values_.end();
+    return base::Contains(valid_values_, value);
   }
 
   const std::vector<T>& GetValues() const { return valid_values_; }

gpu/command_buffer/service/webgpu_decoder_impl.cc

@@ -9,11 +9,11 @@
 #include <dawn/platform/DawnPlatform.h>
 #include <dawn/wire/WireServer.h>
 
-#include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "base/bits.h"
+#include "base/containers/contains.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/raw_ptr.h"
@@ -1081,8 +1081,7 @@ WebGPUDecoderImpl::WebGPUDecoderImpl(
   // Only allow unsafe APIs if the disallow_unsafe_apis toggle is explicitly
   // disabled.
   allow_unsafe_apis_ =
-      std::find(force_disabled_toggles_.begin(), force_disabled_toggles_.end(),
-                "disallow_unsafe_apis") != force_disabled_toggles_.end();
+      base::Contains(force_disabled_toggles_, "disallow_unsafe_apis");
 
   DawnProcTable wire_procs = dawn::native::GetProcs();
   wire_procs.createInstance =

gpu/config/gpu_feature_info.cc

@@ -4,8 +4,7 @@
 
 #include "gpu/config/gpu_feature_info.h"
 
-#include <algorithm>
-
+#include "base/containers/contains.h"
 #include "gpu/config/gpu_blocklist.h"
 #include "gpu/config/gpu_driver_bug_list.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
@@ -42,10 +41,7 @@ void GpuFeatureInfo::ApplyToGLContext(gl::GLContext* gl_context) const {
 }
 
 bool GpuFeatureInfo::IsWorkaroundEnabled(int32_t workaround) const {
-  return std::find(this->enabled_gpu_driver_bug_workarounds.begin(),
-                   this->enabled_gpu_driver_bug_workarounds.end(),
-                   workaround) !=
-         this->enabled_gpu_driver_bug_workarounds.end();
+  return base::Contains(this->enabled_gpu_driver_bug_workarounds, workaround);
 }
 
 bool GpuFeatureInfo::IsInitialized() const {

gpu/config/gpu_switching.cc

@@ -10,10 +10,10 @@
 #include <OpenGL/OpenGL.h>
 #endif
 
-#include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/containers/contains.h"
 #include "gpu/config/gpu_driver_bug_workaround_type.h"
 #include "gpu/config/gpu_info.h"
 #include "ui/gl/gl_context.h"
@@ -37,12 +37,6 @@ typedef void* PlatformPixelFormatObj;
 
 PlatformPixelFormatObj g_discrete_pixel_format_obj = nullptr;
 
-bool ContainsWorkaround(const std::vector<int32_t>& workarounds,
-                        int32_t workaround) {
-  return (std::find(workarounds.begin(), workarounds.end(), workaround) !=
-          workarounds.end());
-}
-
 void ForceDiscreteGPU() {
   if (g_discrete_pixel_format_obj)
     return;
@@ -98,10 +92,10 @@ bool SwitchableGPUsSupported(const GPUInfo& gpu_info,
 void InitializeSwitchableGPUs(
     const std::vector<int32_t>& driver_bug_workarounds) {
   gl::GLContext::SetSwitchableGPUsSupported();
-  if (ContainsWorkaround(driver_bug_workarounds, FORCE_HIGH_PERFORMANCE_GPU)) {
+  if (base::Contains(driver_bug_workarounds, FORCE_HIGH_PERFORMANCE_GPU)) {
     gl::GLSurface::SetForcedGpuPreference(gl::GpuPreference::kHighPerformance);
     ForceDiscreteGPU();
-  } else if (ContainsWorkaround(driver_bug_workarounds, FORCE_LOW_POWER_GPU)) {
+  } else if (base::Contains(driver_bug_workarounds, FORCE_LOW_POWER_GPU)) {
     gl::GLSurface::SetForcedGpuPreference(gl::GpuPreference::kLowPower);
   }
 }

gpu/gles2_conform_support/egl/display.cc

@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include "base/ranges/algorithm.h"
 #include "build/build_config.h"
 #include "gpu/gles2_conform_support/egl/config.h"
 #include "gpu/gles2_conform_support/egl/context.h"
@@ -236,7 +237,7 @@ EGLBoolean Display::DestroySurface(ThreadState* ts, EGLSurface sfe) {
   base::AutoLock auto_lock(lock_);
   if (!is_initialized_)
     return ts->ReturnError(EGL_NOT_INITIALIZED, EGL_FALSE);
-  auto it = std::find(surfaces_.begin(), surfaces_.end(), sfe);
+  auto it = base::ranges::find(surfaces_, sfe);
   if (it == surfaces_.end())
     return ts->ReturnError(EGL_BAD_SURFACE, EGL_FALSE);
   surfaces_.erase(it);
@@ -347,7 +348,7 @@ EGLBoolean Display::DestroyContext(ThreadState* ts, EGLContext ctx) {
   base::AutoLock auto_lock(lock_);
   if (!is_initialized_)
     return ts->ReturnError(EGL_NOT_INITIALIZED, EGL_FALSE);
-  auto it = std::find(contexts_.begin(), contexts_.end(), ctx);
+  auto it = base::ranges::find(contexts_, ctx);
   if (it == contexts_.end())
     return ts->ReturnError(EGL_BAD_CONTEXT, EGL_FALSE);
   (*it)->MarkDestroyed();
@@ -383,15 +384,15 @@ const Config* Display::GetConfig(EGLConfig cfg) {
 
 Surface* Display::GetSurface(EGLSurface surface) {
   lock_.AssertAcquired();
-  auto it = std::find(surfaces_.begin(), surfaces_.end(), surface);
+  auto it = base::ranges::find(surfaces_, surface);
   if (it == surfaces_.end())
     return nullptr;
   return it->get();
 }
 
 Context* Display::GetContext(EGLContext context) {
   lock_.AssertAcquired();
-  auto it = std::find(contexts_.begin(), contexts_.end(), context);
+  auto it = base::ranges::find(contexts_, context);
   if (it == contexts_.end())
     return nullptr;
   return it->get();