content: Use stl utilities from the base namespace

content/browser/loader/resource_scheduler.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 "content/browser/loader/resource_scheduler.h"
 
 #include <stdint.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 118 matching lines @@
   NetQueue::iterator GetNextHighestIterator() {
     return queue_.begin();
   }
 
   NetQueue::iterator End() {
     return queue_.end();
   }
 
   // Returns true if |request| is queued.
   bool IsQueued(ScheduledResourceRequest* request) const {
-    return ContainsKey(pointers_, request);
+    return base::ContainsKey(pointers_, request);
   }
 
   // Returns true if no requests are queued.
   bool IsEmpty() const { return queue_.size() == 0; }
 
  private:
   typedef std::map<ScheduledResourceRequest*, NetQueue::iterator> PointerMap;
 
   uint32_t MakeFifoOrderingId() {
     fifo_ordering_ids_ += 1;
@@ skipping 145 matching lines @@
     return a->get_request_priority_params().GreaterThan(
         b->get_request_priority_params());
 
   // If priority/intra_priority is the same, fall back to fifo ordering.
   // std::multiset doesn't guarantee this until c++11.
   return a->fifo_ordering() < b->fifo_ordering();
 }
 
 void ResourceScheduler::RequestQueue::Insert(
     ScheduledResourceRequest* request) {
-  DCHECK(!ContainsKey(pointers_, request));
+  DCHECK(!base::ContainsKey(pointers_, request));
   request->set_fifo_ordering(MakeFifoOrderingId());
   pointers_[request] = queue_.insert(request);
 }
 
 // Each client represents a tab.
 class ResourceScheduler::Client {
  public:
   explicit Client(ResourceScheduler* scheduler)
       : is_loaded_(false),
         has_html_body_(false),
@@ skipping 11 matching lines @@
       // New requests can be started synchronously without issue.
       StartRequest(request, START_SYNC);
     } else {
       pending_requests_.Insert(request);
     }
   }
 
   void RemoveRequest(ScheduledResourceRequest* request) {
     if (pending_requests_.IsQueued(request)) {
       pending_requests_.Erase(request);
-      DCHECK(!ContainsKey(in_flight_requests_, request));
+      DCHECK(!base::ContainsKey(in_flight_requests_, request));
     } else {
       EraseInFlightRequest(request);
 
       // Removing this request may have freed up another to load.
       LoadAnyStartablePendingRequests();
     }
   }
 
   RequestSet StartAndRemoveAllRequests() {
     // First start any pending requests so that they will be moved into
@@ skipping 43 matching lines @@
     }
   }
 
   void ReprioritizeRequest(ScheduledResourceRequest* request,
                            RequestPriorityParams old_priority_params,
                            RequestPriorityParams new_priority_params) {
     request->url_request()->SetPriority(new_priority_params.priority);
     request->set_request_priority_params(new_priority_params);
     SetRequestAttributes(request, DetermineRequestAttributes(request));
     if (!pending_requests_.IsQueued(request)) {
-      DCHECK(ContainsKey(in_flight_requests_, request));
+      DCHECK(base::ContainsKey(in_flight_requests_, request));
       // Request has already started.
       return;
     }
 
     pending_requests_.Erase(request);
     pending_requests_.Insert(request);
 
     if (new_priority_params.priority > old_priority_params.priority) {
       // Check if this request is now able to load at its new priority.
       LoadAnyStartablePendingRequests();
@@ skipping 39 matching lines @@
       for (RequestQueue::NetQueue::const_iterator
            it = pending_requests_.GetNextHighestIterator();
            it != pending_requests_.End(); ++it) {
         if (RequestAttributesAreSet((*it)->attributes(), attributes))
           matching_request_count++;
         if (*it == current_request)
           current_request_is_pending = true;
       }
       // Account for the current request if it is not in one of the lists yet.
       if (current_request &&
-          !ContainsKey(in_flight_requests_, current_request) &&
+          !base::ContainsKey(in_flight_requests_, current_request) &&
           !current_request_is_pending) {
         if (RequestAttributesAreSet(current_request->attributes(), attributes))
           matching_request_count++;
       }
     }
     return matching_request_count;
   }
 
   bool RequestAttributesAreSet(RequestAttributes request_attributes,
                                RequestAttributes matching_attributes) const {
@@ skipping 25 matching lines @@
         kAttributeInFlight | kAttributeDelayable, request),
         in_flight_delayable_count_);
     DCHECK_EQ(CountRequestsWithAttributes(kAttributeLayoutBlocking, request),
               total_layout_blocking_count_);
   }
 
   RequestAttributes DetermineRequestAttributes(
       ScheduledResourceRequest* request) {
     RequestAttributes attributes = kAttributeNone;
 
-    if (ContainsKey(in_flight_requests_, request))
+    if (base::ContainsKey(in_flight_requests_, request))
       attributes |= kAttributeInFlight;
 
     if (RequestAttributesAreSet(request->attributes(),
                                 kAttributeLayoutBlocking)) {
       // If a request is already marked as layout-blocking make sure to keep the
       // attribute across redirects.
       attributes |= kAttributeLayoutBlocking;
     } else if (!has_html_body_ &&
                request->url_request()->priority() >
                kLayoutBlockingPriorityThreshold) {
@@ skipping 246 matching lines @@
     return std::move(request);
   }
 
   Client* client = it->second;
   client->ScheduleRequest(url_request, request.get());
   return std::move(request);
 }
 
 void ResourceScheduler::RemoveRequest(ScheduledResourceRequest* request) {
   DCHECK(CalledOnValidThread());
-  if (ContainsKey(unowned_requests_, request)) {
+  if (base::ContainsKey(unowned_requests_, request)) {
     unowned_requests_.erase(request);
     return;
   }
 
   ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     return;
   }
 
   Client* client = client_it->second;
   client->RemoveRequest(request);
 }
 
 void ResourceScheduler::OnClientCreated(int child_id,
                                         int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
-  DCHECK(!ContainsKey(client_map_, client_id));
+  DCHECK(!base::ContainsKey(client_map_, client_id));
 
   Client* client = new Client(this);
   client_map_[client_id] = client;
 }
 
 void ResourceScheduler::OnClientDeleted(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
   ClientMap::iterator it = client_map_.find(client_id);
   DCHECK(it != client_map_.end());
@@ skipping 120 matching lines @@
   client->ReprioritizeRequest(scheduled_resource_request, old_priority_params,
                               new_priority_params);
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content