device: Use stl utilities from the base namespace

device/usb/usb_device_handle_impl.cc

 // Copyright 2014 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 "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <utility>
@@ skipping 594 matching lines @@
                  configuration_value, callback));
 }
 
 void UsbDeviceHandleImpl::ClaimInterface(int interface_number,
                                          const ResultCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_) {
     callback.Run(false);
     return;
   }
-  if (ContainsKey(claimed_interfaces_, interface_number)) {
+  if (base::ContainsKey(claimed_interfaces_, interface_number)) {
     callback.Run(true);
     return;
   }
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UsbDeviceHandleImpl::ClaimInterfaceOnBlockingThread, this,
                  interface_number, callback));
 }
 
 void UsbDeviceHandleImpl::ReleaseInterface(int interface_number,
                                            const ResultCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_ || !ContainsKey(claimed_interfaces_, interface_number)) {
+  if (!device_ || !base::ContainsKey(claimed_interfaces_, interface_number)) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
     return;
   }
 
   // Cancel all the transfers on that interface.
   InterfaceClaimer* interface_claimer =
       claimed_interfaces_[interface_number].get();
   for (Transfer* transfer : transfers_) {
     if (transfer->claimed_interface() == interface_claimer) {
       transfer->Cancel();
     }
   }
   interface_claimer->AddRef();
   interface_claimer->set_release_callback(callback);
   blocking_task_runner_->ReleaseSoon(FROM_HERE, interface_claimer);
   claimed_interfaces_.erase(interface_number);
 
   RefreshEndpointMap();
 }
 
 void UsbDeviceHandleImpl::SetInterfaceAlternateSetting(
     int interface_number,
     int alternate_setting,
     const ResultCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!device_ || !ContainsKey(claimed_interfaces_, interface_number)) {
+  if (!device_ || !base::ContainsKey(claimed_interfaces_, interface_number)) {
     callback.Run(false);
     return;
   }
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &UsbDeviceHandleImpl::SetInterfaceAlternateSettingOnBlockingThread,
           this, interface_number, alternate_setting, callback));
 }
@@ skipping 440 matching lines @@
   // object holds a weak reference.
   transfers_.insert(transfer.get());
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Transfer::Submit, base::Unretained(transfer.release())));
 }
 
 void UsbDeviceHandleImpl::TransferComplete(Transfer* transfer,
                                            const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(ContainsKey(transfers_, transfer)) << "Missing transfer completed";
+  DCHECK(base::ContainsKey(transfers_, transfer))
+      << "Missing transfer completed";
   transfers_.erase(transfer);
 
   if (transfer->callback_task_runner()->RunsTasksOnCurrentThread()) {
     callback.Run();
   } else {
     transfer->callback_task_runner()->PostTask(FROM_HERE, callback);
   }
 
   // libusb_free_transfer races with libusb_submit_transfer and only work-
   // around is to make sure to call them on the same thread.
   blocking_task_runner_->DeleteSoon(FROM_HERE, transfer);
 }
 
 }  // namespace device