ScopedPtrMap -> std::map from /component

components/policy/core/common/schema.cc

 // Copyright 2013 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/schema.h"
 
 #include <algorithm>
 #include <climits>
 #include <map>
 #include <utility>
 
 #include "base/compiler_specific.h"
-#include "base/containers/scoped_ptr_map.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "components/json_schema/json_schema_constants.h"
 #include "components/json_schema/json_schema_validator.h"
 #include "components/policy/core/common/schema_internal.h"
 #include "third_party/re2/re2/re2.h"
 
 namespace schema = json_schema_constants;
 
 namespace policy {
 
@@ skipping 213 matching lines @@
 
   // Assigns the IDs in |id_map| to the pending references in the
   // |reference_list|. If an ID is missing then |error| is set and false is
   // returned; otherwise returns true.
   static bool ResolveReferences(const IdMap& id_map,
                                 const ReferenceList& reference_list,
                                 std::string* error);
 
   // Cache for CompileRegex(), will memorize return value of every call to
   // CompileRegex() and return results directly next time.
-  mutable base::ScopedPtrMap<std::string, scoped_ptr<re2::RE2>> regex_cache_;
+  mutable std::map<std::string, scoped_ptr<re2::RE2>> regex_cache_;
 
   SchemaData schema_data_;
   std::vector<std::string> strings_;
   std::vector<SchemaNode> schema_nodes_;
   std::vector<PropertyNode> property_nodes_;
   std::vector<PropertiesNode> properties_nodes_;
   std::vector<RestrictionNode> restriction_nodes_;
   std::vector<int> int_enums_;
   std::vector<const char*> string_enums_;
 
@@ skipping 74 matching lines @@
   data->property_nodes = storage->property_nodes_.data();
   data->properties_nodes = storage->properties_nodes_.data();
   data->restriction_nodes = storage->restriction_nodes_.data();
   data->int_enums = storage->int_enums_.data();
   data->string_enums = storage->string_enums_.data();
   return storage;
 }
 
 re2::RE2* Schema::InternalStorage::CompileRegex(
     const std::string& pattern) const {
-  base::ScopedPtrMap<std::string, scoped_ptr<re2::RE2>>::const_iterator it =
-      regex_cache_.find(pattern);
+  auto it = regex_cache_.find(pattern);
   if (it == regex_cache_.end()) {
     scoped_ptr<re2::RE2> compiled(new re2::RE2(pattern));
     re2::RE2* compiled_ptr = compiled.get();
-    regex_cache_.insert(pattern, compiled.Pass());
+    regex_cache_.insert(std::make_pair(pattern, std::move(compiled)));
     return compiled_ptr;
   }
-  return it->second;
+  return it->second.get();
 }
 
 // static
 void Schema::InternalStorage::DetermineStorageSizes(
     const base::DictionaryValue& schema,
     StorageSizes* sizes) {
   std::string ref_string;
   if (schema.GetString(schema::kRef, &ref_string)) {
     // Schemas with a "$ref" attribute don't take additional storage.
     return;
@@ skipping 737 matching lines @@
     return false;
   } else {
     int index = rnode->string_pattern_restriction.pattern_index;
     DCHECK(index == rnode->string_pattern_restriction.pattern_index_backup);
     re2::RE2* regex = storage_->CompileRegex(*storage_->string_enums(index));
     return re2::RE2::PartialMatch(str, *regex);
   }
 }
 
 }  // namespace policy