components: Use stl utilities from the base namespace

components/policy/core/common/cloud/cloud_policy_client.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 "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 51 matching lines @@
       public_key_version_(-1),
       public_key_version_valid_(false),
       invalidation_version_(0),
       fetched_invalidation_version_(0),
       service_(service),                  // Can be null for unit tests.
       status_(DM_STATUS_SUCCESS),
       request_context_(request_context) {
 }
 
 CloudPolicyClient::~CloudPolicyClient() {
-  STLDeleteValues(&responses_);
+  base::STLDeleteValues(&responses_);
 }
 
 void CloudPolicyClient::SetupRegistration(const std::string& dm_token,
                                           const std::string& client_id) {
   DCHECK(!dm_token.empty());
   DCHECK(!client_id.empty());
   DCHECK(!is_registered());
 
   dm_token_ = dm_token;
   client_id_ = client_id;
   request_jobs_.clear();
   policy_fetch_request_job_.reset();
-  STLDeleteValues(&responses_);
+  base::STLDeleteValues(&responses_);
 
   NotifyRegistrationStateChanged();
 }
 
 void CloudPolicyClient::Register(em::DeviceRegisterRequest::Type type,
                                  em::DeviceRegisterRequest::Flavor flavor,
                                  const std::string& auth_token,
                                  const std::string& client_id,
                                  const std::string& requisition,
                                  const std::string& current_state_key) {
@@ skipping 417 matching lines @@
         response.policy_response().response_size() == 0) {
       LOG(WARNING) << "Empty policy response.";
       status = DM_STATUS_RESPONSE_DECODING_ERROR;
     }
   }
 
   status_ = status;
   if (status == DM_STATUS_SUCCESS) {
     const em::DevicePolicyResponse& policy_response =
         response.policy_response();
-    STLDeleteValues(&responses_);
+    base::STLDeleteValues(&responses_);
     for (int i = 0; i < policy_response.response_size(); ++i) {
       const em::PolicyFetchResponse& response = policy_response.response(i);
       em::PolicyData policy_data;
       if (!policy_data.ParseFromString(response.policy_data()) ||
           !policy_data.IsInitialized() ||
           !policy_data.has_policy_type()) {
         LOG(WARNING) << "Invalid PolicyData received, ignoring";
         continue;
       }
       const std::string& type = policy_data.policy_type();
       std::string entity_id;
       if (policy_data.has_settings_entity_id())
         entity_id = policy_data.settings_entity_id();
       std::pair<std::string, std::string> key(type, entity_id);
-      if (ContainsKey(responses_, key)) {
+      if (base::ContainsKey(responses_, key)) {
         LOG(WARNING) << "Duplicate PolicyFetchResponse for type: "
             << type << ", entity: " << entity_id << ", ignoring";
         continue;
       }
       responses_[key] = new em::PolicyFetchResponse(response);
     }
     state_keys_to_upload_.clear();
     NotifyPolicyFetched();
   } else {
     NotifyClientError();
@@ skipping 168 matching lines @@
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy