Use ContainsValue() instead of std::find() in chrome/browser and chrome/common

chrome/browser/custom_handlers/protocol_handler_registry.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/child_process_security_policy.h"
@@ skipping 441 matching lines @@
   return !delegate_->IsExternalHandlerRegistered(scheme);
 }
 
 bool ProtocolHandlerRegistry::IsRegistered(
     const ProtocolHandler& handler) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const ProtocolHandlerList* handlers = GetHandlerList(handler.protocol());
   if (!handlers) {
     return false;
   }
-  return std::find(handlers->begin(), handlers->end(), handler) !=
-      handlers->end();
+  return base::ContainsValue(*handlers, handler);
 }
 
 bool ProtocolHandlerRegistry::IsRegisteredByUser(
     const ProtocolHandler& handler) {
   return HandlerExists(handler, &user_protocol_handlers_);
 }
 
 bool ProtocolHandlerRegistry::HasPolicyRegisteredHandler(
     const std::string& scheme) {
   return (policy_protocol_handlers_.find(scheme) !=
@@ skipping 365 matching lines @@
   }
 }
 
 bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
                                             ProtocolHandlerMultiMap* map) {
   return HandlerExists(handler, (*map)[handler.protocol()]);
 }
 
 bool ProtocolHandlerRegistry::HandlerExists(const ProtocolHandler& handler,
                                             const ProtocolHandlerList& list) {
-  return std::find(list.begin(), list.end(), handler) != list.end();
+  return base::ContainsValue(list, handler);
 }
 
 void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
                                            ProtocolHandlerMultiMap* map) {
   EraseHandler(handler, &(*map)[handler.protocol()]);
 }
 
 void ProtocolHandlerRegistry::EraseHandler(const ProtocolHandler& handler,
                                            ProtocolHandlerList* list) {
   list->erase(std::find(list->begin(), list->end(), handler));
@@ skipping 25 matching lines @@
 
 std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
   return std::unique_ptr<JobInterceptorFactory>(
       new JobInterceptorFactory(io_thread_delegate_.get()));
 }