Convert //components/policy from scoped_ptr to std::unique_ptr

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 <limits.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <climits>
 #include <map>
+#include <memory>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.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/src/re2/re2.h"
 
 namespace schema = json_schema_constants;
 
 namespace policy {
@@ skipping 214 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, scoped_ptr<re2::RE2>> regex_cache_;
+  mutable std::map<std::string, std::unique_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 76 matching lines @@
   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 {
   auto it = regex_cache_.find(pattern);
   if (it == regex_cache_.end()) {
-    scoped_ptr<re2::RE2> compiled(new re2::RE2(pattern));
+    std::unique_ptr<re2::RE2> compiled(new re2::RE2(pattern));
     re2::RE2* compiled_ptr = compiled.get();
     regex_cache_.insert(std::make_pair(pattern, std::move(compiled)));
     return compiled_ptr;
   }
   return it->second.get();
 }
 
 // static
 void Schema::InternalStorage::DetermineStorageSizes(
     const base::DictionaryValue& schema,
@@ skipping 587 matching lines @@
     return true;
   }
 
   return Validate(*value, strategy, error_path, error);
 }
 
 // static
 Schema Schema::Parse(const std::string& content, std::string* error) {
   // Validate as a generic JSON schema, and ignore unknown attributes; they
   // may become used in a future version of the schema format.
-  scoped_ptr<base::DictionaryValue> dict = JSONSchemaValidator::IsValidSchema(
-      content, JSONSchemaValidator::OPTIONS_IGNORE_UNKNOWN_ATTRIBUTES, error);
+  std::unique_ptr<base::DictionaryValue> dict =
+      JSONSchemaValidator::IsValidSchema(
+          content, JSONSchemaValidator::OPTIONS_IGNORE_UNKNOWN_ATTRIBUTES,
+          error);
   if (!dict)
     return Schema();
 
   // Validate the main type.
   std::string string_value;
   if (!dict->GetString(schema::kType, &string_value) ||
       string_value != schema::kObject) {
     *error =
         "The main schema must have a type attribute with \"object\" value.";
     return Schema();
@@ skipping 133 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