Update usages of std::map to use ScopedPtrMap.

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/memory/scoped_vector.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 std::map<std::string, re2::RE2*> regex_cache_;
-  STLValueDeleter<std::map<std::string, re2::RE2*> > regex_cache_deleter_;
+  mutable base::ScopedPtrMap<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_;
 
   DISALLOW_COPY_AND_ASSIGN(InternalStorage);
 };
 
-Schema::InternalStorage::InternalStorage()
-    : regex_cache_deleter_(&regex_cache_) {}
+Schema::InternalStorage::InternalStorage() {
+}
 
-Schema::InternalStorage::~InternalStorage() {}
+Schema::InternalStorage::~InternalStorage() {
+}
 
 // static
 scoped_refptr<const Schema::InternalStorage> Schema::InternalStorage::Wrap(
     const SchemaData* data) {
   InternalStorage* storage = new InternalStorage();
   storage->schema_data_.schema_nodes = data->schema_nodes;
   storage->schema_data_.property_nodes = data->property_nodes;
   storage->schema_data_.properties_nodes = data->properties_nodes;
   storage->schema_data_.restriction_nodes = data->restriction_nodes;
   storage->schema_data_.int_enums = data->int_enums;
@@ skipping 56 matching lines @@
   data->property_nodes = vector_as_array(&storage->property_nodes_);
   data->properties_nodes = vector_as_array(&storage->properties_nodes_);
   data->restriction_nodes = vector_as_array(&storage->restriction_nodes_);
   data->int_enums = vector_as_array(&storage->int_enums_);
   data->string_enums = vector_as_array(&storage->string_enums_);
   return storage;
 }
 
 re2::RE2* Schema::InternalStorage::CompileRegex(
     const std::string& pattern) const {
-  std::map<std::string, re2::RE2*>::iterator it = regex_cache_.find(pattern);
+  base::ScopedPtrMap<std::string, scoped_ptr<re2::RE2>>::const_iterator it =
+      regex_cache_.find(pattern);
   if (it == regex_cache_.end()) {
-    re2::RE2* compiled = new re2::RE2(pattern);
-    regex_cache_[pattern] = compiled;
-    return compiled;
+    scoped_ptr<re2::RE2> compiled(new re2::RE2(pattern));
+    re2::RE2* compiled_ptr = compiled.get();
+    regex_cache_.insert(pattern, compiled.Pass());
+    return compiled_ptr;
   }
   return it->second;
 }
 
 // static
 void Schema::InternalStorage::DetermineStorageSizes(
     const base::DictionaryValue& schema,
     StorageSizes* sizes) {
   std::string ref_string;
   if (schema.GetString(schema::kRef, &ref_string)) {
@@ skipping 739 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