Change std::find_if*() to use base:: functions: media/

Goal: Slightly simpler and/or more semantically-accurate code.

Bug: none
Change-Id: I9857de9d1a7b88813f03706d7f7a3d7f1cfbbaf8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3909993
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Ted (Chromium) Meyer <tmathmeyer@chromium.org>
Commit-Queue: Ted (Chromium) Meyer <tmathmeyer@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1051478}

media/audio/audio_manager_base.cc

@@ -12,6 +12,7 @@
 #include "base/memory/raw_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/observer_list.h"
+#include "base/ranges/algorithm.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/single_thread_task_runner.h"
@@ -98,26 +99,6 @@ struct AudioManagerBase::DispatcherParams {
   std::unique_ptr<AudioOutputDispatcher> dispatcher;
 };
 
-class AudioManagerBase::CompareByParams {
- public:
-  explicit CompareByParams(const DispatcherParams* dispatcher)
-      : dispatcher_(dispatcher) {}
-  bool operator()(
-      const std::unique_ptr<DispatcherParams>& dispatcher_in) const {
-    // We will reuse the existing dispatcher when:
-    // 1) Unified IO is not used, input_params and output_params of the
-    //    existing dispatcher are the same as the requested dispatcher.
-    // 2) Unified IO is used, input_params and output_params of the existing
-    //    dispatcher are the same as the request dispatcher.
-    return (dispatcher_->input_params.Equals(dispatcher_in->input_params) &&
-            dispatcher_->output_params.Equals(dispatcher_in->output_params) &&
-            dispatcher_->output_device_id == dispatcher_in->output_device_id);
-  }
-
- private:
-  raw_ptr<const DispatcherParams> dispatcher_;
-};
-
 AudioManagerBase::AudioManagerBase(std::unique_ptr<AudioThread> audio_thread,
                                    AudioLogFactory* audio_log_factory)
     : AudioManager(std::move(audio_thread)),
@@ -424,12 +405,21 @@ AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
     NOTREACHED();
   }
 
-  std::unique_ptr<DispatcherParams> dispatcher_params =
-      std::make_unique<DispatcherParams>(params, output_params,
-                                         output_device_id);
-
-  auto it = std::find_if(output_dispatchers_.begin(), output_dispatchers_.end(),
-                         CompareByParams(dispatcher_params.get()));
+  auto dispatcher_params = std::make_unique<DispatcherParams>(
+      params, output_params, output_device_id);
+
+  auto it = base::ranges::find_if(
+      output_dispatchers_,
+      [&](const std::unique_ptr<DispatcherParams>& dispatcher) {
+        // We will reuse the existing dispatcher when:
+        // 1) Unified IO is not used, input_params and output_params of the
+        //    existing dispatcher are the same as the requested dispatcher.
+        // 2) Unified IO is used, input_params and output_params of the existing
+        //    dispatcher are the same as the request dispatcher.
+        return params.Equals(dispatcher->input_params) &&
+               output_params.Equals(dispatcher->output_params) &&
+               output_device_id == dispatcher->output_device_id;
+      });
   if (it != output_dispatchers_.end())
     return (*it)->dispatcher->CreateStreamProxy();
 

media/audio/audio_manager_base.h

@@ -184,8 +184,6 @@ class MEDIA_EXPORT AudioManagerBase : public AudioManager {
   struct DispatcherParams;
   typedef std::vector<std::unique_ptr<DispatcherParams>> AudioOutputDispatchers;
 
-  class CompareByParams;
-
   // AudioManager:
   void InitializeDebugRecording() final;
 

media/audio/audio_manager_unittest.cc

@@ -14,6 +14,7 @@
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
+#include "base/ranges/algorithm.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -450,11 +451,8 @@ class AudioManagerTest : public ::testing::Test {
   // Helper method for (USE_CRAS) which returns |group_id| from |device_id|.
   std::string getGroupID(const AudioDeviceDescriptions& device_descriptions,
                          const std::string device_id) {
-    AudioDeviceDescriptions::const_iterator it =
-        std::find_if(device_descriptions.begin(), device_descriptions.end(),
-                     [&device_id](const auto& audio_device_desc) {
-                       return audio_device_desc.unique_id == device_id;
-                     });
+    AudioDeviceDescriptions::const_iterator it = base::ranges::find(
+        device_descriptions, device_id, &AudioDeviceDescription::unique_id);
 
     EXPECT_NE(it, device_descriptions.end());
     return it->group_id;

media/audio/cras/audio_manager_chromeos.cc

@@ -6,7 +6,6 @@
 
 #include <stddef.h>
 
-#include <algorithm>
 #include <map>
 #include <utility>
 
@@ -16,6 +15,7 @@
 #include "base/environment.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/nix/xdg_util.h"
+#include "base/ranges/algorithm.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/system/sys_info.h"
@@ -294,8 +294,8 @@ std::string AudioManagerChromeOS::GetAssociatedOutputDeviceID(
     return "";
 
   // Now search for an output device with the same device name.
-  auto output_device_it = std::find_if(
-      devices.begin(), devices.end(), [device_name](const AudioDevice& device) {
+  auto output_device_it =
+      base::ranges::find_if(devices, [device_name](const AudioDevice& device) {
         return !device.is_input && device.device_name == device_name;
       });
   return output_device_it == devices.end()

media/audio/fuchsia/audio_manager_fuchsia.cc

@@ -10,6 +10,7 @@
 
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/containers/contains.h"
 #include "base/fuchsia/fuchsia_logging.h"
 #include "base/fuchsia/process_context.h"
 #include "base/fuchsia/scheduler.h"
@@ -234,10 +235,9 @@ void AudioManagerFuchsia::OnDeviceRemoved(uint64_t device_token) {
 bool AudioManagerFuchsia::HasAudioDevice(bool is_input) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
-  return std::find_if(audio_devices_.begin(), audio_devices_.end(),
-                      [is_input](const auto& device) {
-                        return device.second.is_input == is_input;
-                      }) != audio_devices_.end();
+  return base::Contains(audio_devices_, is_input, [](const auto& device) {
+    return device.second.is_input;
+  });
 }
 
 void AudioManagerFuchsia::GetAudioDevices(AudioDeviceNames* device_names,

media/capture/video/android/video_capture_device_android.cc

@@ -12,6 +12,7 @@
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/ranges/algorithm.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ -391,11 +392,9 @@ void VideoCaptureDeviceAndroid::OnGetPhotoCapabilitiesReply(
   GetPhotoStateCallback* const cb =
       reinterpret_cast<GetPhotoStateCallback*>(callback_id);
   // Search for the pointer |cb| in the list of |take_photo_callbacks_|.
-  const auto reference_it = std::find_if(
-      get_photo_state_callbacks_.begin(), get_photo_state_callbacks_.end(),
-      [cb](const std::unique_ptr<GetPhotoStateCallback>& callback) {
-        return callback.get() == cb;
-      });
+  const auto reference_it =
+      base::ranges::find(get_photo_state_callbacks_, cb,
+                         &std::unique_ptr<GetPhotoStateCallback>::get);
   if (reference_it == get_photo_state_callbacks_.end()) {
     NOTREACHED() << "|callback_id| not found.";
     return;
@@ -557,11 +556,8 @@ void VideoCaptureDeviceAndroid::OnPhotoTaken(
   TakePhotoCallback* const cb =
       reinterpret_cast<TakePhotoCallback*>(callback_id);
   // Search for the pointer |cb| in the list of |take_photo_callbacks_|.
-  const auto reference_it =
-      std::find_if(take_photo_callbacks_.begin(), take_photo_callbacks_.end(),
-                   [cb](const std::unique_ptr<TakePhotoCallback>& callback) {
-                     return callback.get() == cb;
-                   });
+  const auto reference_it = base::ranges::find(
+      take_photo_callbacks_, cb, &std::unique_ptr<TakePhotoCallback>::get);
   if (reference_it == take_photo_callbacks_.end()) {
     NOTREACHED() << "|callback_id| not found.";
     return;

media/capture/video/chromeos/camera_metadata_utils.cc

@@ -4,10 +4,10 @@
 
 #include "media/capture/video/chromeos/camera_metadata_utils.h"
 
-#include <algorithm>
 #include <unordered_set>
 
 #include "base/containers/span.h"
+#include "base/ranges/algorithm.h"
 
 namespace media {
 
@@ -48,11 +48,8 @@ cros::mojom::CameraMetadataEntryPtr* GetMetadataEntry(
     return nullptr;
   }
   // We assume the metadata entries are sorted.
-  auto iter = std::find_if(camera_metadata->entries.value().begin(),
-                           camera_metadata->entries.value().end(),
-                           [tag](const cros::mojom::CameraMetadataEntryPtr& e) {
-                             return e->tag == tag;
-                           });
+  auto iter = base::ranges::find(camera_metadata->entries.value(), tag,
+                                 &cros::mojom::CameraMetadataEntry::tag);
   if (iter == camera_metadata->entries.value().end()) {
     return nullptr;
   }

media/capture/video/linux/fake_device_provider.cc

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 
+#include "base/ranges/algorithm.h"
 #include "media/capture/video/video_capture_device_descriptor.h"
 #include "media/capture/video_capture_types.h"
 
@@ -28,11 +29,8 @@ void FakeDeviceProvider::GetDeviceIds(
 }
 
 std::string FakeDeviceProvider::GetDeviceModelId(const std::string& device_id) {
-  auto iter =
-      std::find_if(descriptors_.begin(), descriptors_.end(),
-                   [&device_id](const VideoCaptureDeviceDescriptor& val) {
-                     return val.device_id == device_id;
-                   });
+  auto iter = base::ranges::find(descriptors_, device_id,
+                                 &VideoCaptureDeviceDescriptor::device_id);
   if (iter == descriptors_.end())
     CHECK(false) << "Unknown device_id " << device_id;
 
@@ -41,11 +39,8 @@ std::string FakeDeviceProvider::GetDeviceModelId(const std::string& device_id) {
 
 std::string FakeDeviceProvider::GetDeviceDisplayName(
     const std::string& device_id) {
-  auto iter =
-      std::find_if(descriptors_.begin(), descriptors_.end(),
-                   [&device_id](const VideoCaptureDeviceDescriptor& val) {
-                     return val.device_id == device_id;
-                   });
+  auto iter = base::ranges::find(descriptors_, device_id,
+                                 &VideoCaptureDeviceDescriptor::device_id);
   if (iter == descriptors_.end())
     CHECK(false) << "Unknown device_id " << device_id;
 

media/capture/video/linux/fake_v4l2_impl.cc

@@ -8,10 +8,12 @@
 #include <sys/mman.h>
 #include <sys/time.h>
 #include <unistd.h>
+
 #include <queue>
 
 #include "base/bind.h"
 #include "base/bits.h"
+#include "base/ranges/algorithm.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
@@ -88,10 +90,7 @@ class FakeV4L2Impl::OpenedDevice {
 
   FakeV4L2Buffer* LookupBufferFromOffset(off_t offset) {
     auto buffer_iter =
-        std::find_if(device_buffers_.begin(), device_buffers_.end(),
-                     [offset](const FakeV4L2Buffer& buffer) {
-                       return buffer.offset == offset;
-                     });
+        base::ranges::find(device_buffers_, offset, &FakeV4L2Buffer::offset);
     if (buffer_iter == device_buffers_.end())
       return nullptr;
     return &(*buffer_iter);

media/capture/video/video_capture_device_unittest.cc

@@ -12,6 +12,7 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/containers/contains.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/task/single_thread_task_runner.h"
@@ -436,10 +437,8 @@ class VideoCaptureDeviceTest
   bool IsCaptureSizeSupported(const VideoCaptureDeviceInfo& device_info,
                               const gfx::Size& size) {
     auto& supported_formats = device_info.supported_formats;
-    const auto it = std::find_if(
-        supported_formats.begin(), supported_formats.end(),
-        [&size](VideoCaptureFormat const& f) { return f.frame_size == size; });
-    if (it == supported_formats.end()) {
+    if (!base::Contains(supported_formats, size,
+                        &VideoCaptureFormat::frame_size)) {
       DVLOG(1) << "Size " << size.ToString() << " is not supported.";
       return false;
     }

media/capture/video/video_capture_system_impl.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/ranges/algorithm.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
@@ -116,11 +117,10 @@ VideoCaptureErrorOrDevice VideoCaptureSystemImpl::CreateDevice(
 const VideoCaptureDeviceInfo* VideoCaptureSystemImpl::LookupDeviceInfoFromId(
     const std::string& device_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  auto iter =
-      std::find_if(devices_info_cache_.begin(), devices_info_cache_.end(),
-                   [&device_id](const VideoCaptureDeviceInfo& device_info) {
-                     return device_info.descriptor.device_id == device_id;
-                   });
+  auto iter = base::ranges::find(devices_info_cache_, device_id,
+                                 [](const VideoCaptureDeviceInfo& device_info) {
+                                   return device_info.descriptor.device_id;
+                                 });
   if (iter == devices_info_cache_.end())
     return nullptr;
   return &(*iter);

media/capture/video/win/video_capture_device_factory_win.cc

@@ -21,6 +21,7 @@
 #include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/no_destructor.h"
+#include "base/ranges/algorithm.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task/single_thread_task_runner.h"
@@ -258,19 +259,19 @@ std::string GetDeviceModelId(const std::string& device_id) {
 
 bool DevicesInfoContainsDeviceId(const DevicesInfo& devices_info,
                                  const std::string& device_id) {
-  return std::find_if(devices_info.begin(), devices_info.end(),
-                      [device_id](const VideoCaptureDeviceInfo& device_info) {
-                        return device_id == device_info.descriptor.device_id;
-                      }) != devices_info.end();
+  return base::Contains(devices_info, device_id,
+                        [](const VideoCaptureDeviceInfo& device_info) {
+                          return device_info.descriptor.device_id;
+                        });
 }
 
 // Returns a non DirectShow descriptor DevicesInfo with the provided name and
 // model.
 DevicesInfo::const_iterator FindNonDirectShowDeviceInfoByNameAndModel(
     const DevicesInfo& devices_info,
     const std::string& name_and_model) {
-  return std::find_if(
-      devices_info.begin(), devices_info.end(),
+  return base::ranges::find_if(
+      devices_info,
       [name_and_model](const VideoCaptureDeviceInfo& device_info) {
         return device_info.descriptor.capture_api !=
                    VideoCaptureApi::WIN_DIRECT_SHOW &&

media/capture/video/win/video_capture_device_factory_win_unittest.cc

@@ -16,6 +16,7 @@
 
 #include "base/bind.h"
 #include "base/memory/scoped_refptr.h"
+#include "base/ranges/algorithm.h"
 #include "base/run_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/test/bind.h"
@@ -74,10 +75,10 @@ using iterator = std::vector<VideoCaptureDeviceInfo>::const_iterator;
 iterator FindDeviceInRange(iterator begin,
                            iterator end,
                            const std::string& device_id) {
-  return std::find_if(begin, end,
-                      [device_id](const VideoCaptureDeviceInfo& device_info) {
-                        return device_id == device_info.descriptor.device_id;
-                      });
+  return base::ranges::find(begin, end, device_id,
+                            [](const VideoCaptureDeviceInfo& device_info) {
+                              return device_info.descriptor.device_id;
+                            });
 }
 
 template <class Interface>

media/filters/frame_buffer_pool.cc

@@ -11,6 +11,7 @@
 #include "base/location.h"
 #include "base/memory/free_deleter.h"
 #include "base/process/memory.h"
+#include "base/ranges/algorithm.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -58,9 +59,8 @@ uint8_t* FrameBufferPool::GetFrameBuffer(size_t min_size, void** fb_priv) {
   }
 
   // Check if a free frame buffer exists.
-  auto it = std::find_if(
-      frame_buffers_.begin(), frame_buffers_.end(),
-      [](const std::unique_ptr<FrameBuffer>& fb) { return !IsUsed(fb.get()); });
+  auto it = base::ranges::find_if_not(frame_buffers_, &IsUsed,
+                                      &std::unique_ptr<FrameBuffer>::get);
 
   // If not, create one.
   if (it == frame_buffers_.end())