Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/extension.cc

 // Copyright (c) 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 "extensions/common/extension.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 100 matching lines @@
 // TODO(sungguk): Continue removing std::string errors and replacing
 // with base::string16. See http://crbug.com/71980.
 scoped_refptr<Extension> Extension::Create(const base::FilePath& path,
                                            Manifest::Location location,
                                            const base::DictionaryValue& value,
                                            int flags,
                                            const std::string& explicit_id,
                                            std::string* utf8_error) {
   DCHECK(utf8_error);
   base::string16 error;
-  scoped_ptr<extensions::Manifest> manifest(
-      new extensions::Manifest(
-          location, scoped_ptr<base::DictionaryValue>(value.DeepCopy())));
+  std::unique_ptr<extensions::Manifest> manifest(new extensions::Manifest(
+      location, std::unique_ptr<base::DictionaryValue>(value.DeepCopy())));
 
   if (!InitExtensionID(manifest.get(), path, explicit_id, flags, &error)) {
     *utf8_error = base::UTF16ToUTF8(error);
     return NULL;
   }
 
   std::vector<InstallWarning> install_warnings;
   if (!manifest->ValidateManifest(utf8_error, &install_warnings)) {
     return NULL;
   }
@@ skipping 243 matching lines @@
   DCHECK(finished_parsing_manifest_ || thread_checker_.CalledOnValidThread());
   ManifestDataMap::const_iterator iter = manifest_data_.find(key);
   if (iter != manifest_data_.end())
     return iter->second.get();
   return NULL;
 }
 
 void Extension::SetManifestData(const std::string& key,
                                 Extension::ManifestData* data) {
   DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
-  manifest_data_[key] = scoped_ptr<ManifestData>(data);
+  manifest_data_[key] = std::unique_ptr<ManifestData>(data);
 }
 
 Manifest::Location Extension::location() const {
   return manifest_->location();
 }
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
 
@@ skipping 88 matching lines @@
     if (extension_id.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
     manifest->set_extension_id(extension_id);
     return true;
   }
 }
 
 Extension::Extension(const base::FilePath& path,
-                     scoped_ptr<extensions::Manifest> manifest)
+                     std::unique_ptr<extensions::Manifest> manifest)
     : manifest_version_(0),
       converted_from_user_script_(false),
       manifest_(manifest.release()),
       finished_parsing_manifest_(false),
       display_in_launcher_(true),
       display_in_new_tab_page_(true),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
   path_ = crx_file::id_util::MaybeNormalizePath(path);
@@ skipping 270 matching lines @@
     : reason(reason),
       extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet& permissions,
     Reason reason)
     : reason(reason), extension(extension), permissions(permissions) {}
 
 }   // namespace extensions