Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/error_map.cc

 // Copyright 2014 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 "extensions/browser/error_map.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
@@ skipping 80 matching lines @@
   ~ExtensionEntry();
 
   // Delete any errors in the entry that match the given ids and type, if
   // provided.
   // Returns true if any errors were deleted.
   bool DeleteErrors(const ErrorMap::Filter& filter);
   // Delete all errors in the entry.
   void DeleteAllErrors();
 
   // Add the error to the list, and return a weak reference.
-  const ExtensionError* AddError(scoped_ptr<ExtensionError> error);
+  const ExtensionError* AddError(std::unique_ptr<ExtensionError> error);
 
   const ErrorList* list() const { return &list_; }
 
  private:
   // The list of all errors associated with the extension. The errors are
   // owned by the Entry (in turn owned by the ErrorMap) and are deleted upon
   // destruction.
   ErrorList list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionEntry);
@@ skipping 19 matching lines @@
   }
   return deleted;
 }
 
 void ErrorMap::ExtensionEntry::DeleteAllErrors() {
   STLDeleteContainerPointers(list_.begin(), list_.end());
   list_.clear();
 }
 
 const ExtensionError* ErrorMap::ExtensionEntry::AddError(
-    scoped_ptr<ExtensionError> error) {
+    std::unique_ptr<ExtensionError> error) {
   for (ErrorList::iterator iter = list_.begin(); iter != list_.end(); ++iter) {
     // If we find a duplicate error, remove the old error and add the new one,
     // incrementing the occurrence count of the error. We use the new error
     // for runtime errors, so we can link to the latest context, inspectable
     // view, etc.
     if (error->IsEqual(*iter)) {
       error->set_occurrences((*iter)->occurrences() + 1);
       error->set_id((*iter)->id());
       delete *iter;
       list_.erase(iter);
@@ skipping 23 matching lines @@
 ErrorMap::~ErrorMap() {
   RemoveAllErrors();
 }
 
 const ErrorList& ErrorMap::GetErrorsForExtension(
     const std::string& extension_id) const {
   EntryMap::const_iterator iter = map_.find(extension_id);
   return iter != map_.end() ? *iter->second->list() : g_empty_error_list.Get();
 }
 
-const ExtensionError* ErrorMap::AddError(scoped_ptr<ExtensionError> error) {
+const ExtensionError* ErrorMap::AddError(
+    std::unique_ptr<ExtensionError> error) {
   EntryMap::iterator iter = map_.find(error->extension_id());
   if (iter == map_.end()) {
     iter = map_.insert(std::pair<std::string, ExtensionEntry*>(
         error->extension_id(), new ExtensionEntry)).first;
   }
   return iter->second->AddError(std::move(error));
 }
 
 void ErrorMap::RemoveErrors(const Filter& filter,
                             std::set<std::string>* affected_ids) {
@@ skipping 11 matching lines @@
   }
 }
 
 void ErrorMap::RemoveAllErrors() {
   for (EntryMap::iterator iter = map_.begin(); iter != map_.end(); ++iter)
     delete iter->second;
   map_.clear();
 }
 
 }  // namespace extensions