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

extensions/common/extension.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_EXTENSION_H_
 #define EXTENSIONS_COMMON_EXTENSION_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/install_warning.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/url_pattern_set.h"
 #include "url/gurl.h"
 
 #if !defined(ENABLE_EXTENSIONS)
 #error "Extensions must be enabled"
 #endif
@@ skipping 324 matching lines @@
 
   // Chooses the extension ID for an extension based on a variety of criteria.
   // The chosen ID will be set in |manifest|.
   static bool InitExtensionID(extensions::Manifest* manifest,
                               const base::FilePath& path,
                               const ExtensionId& explicit_id,
                               int creation_flags,
                               base::string16* error);
 
   Extension(const base::FilePath& path,
-            scoped_ptr<extensions::Manifest> manifest);
+            std::unique_ptr<extensions::Manifest> manifest);
   virtual ~Extension();
 
   // Initialize the extension from a parsed manifest.
   // TODO(aa): Rename to just Init()? There's no Value here anymore.
   // TODO(aa): It is really weird the way this class essentially contains a copy
   // of the underlying DictionaryValue in its members. We should decide to
   // either wrap the DictionaryValue and go with that only, or we should parse
   // into strong types and discard the value. But doing both is bad.
   bool InitFromValue(int flags, base::string16* error);
 
@@ skipping 44 matching lines @@
 
   // The absolute path to the directory the extension is stored in.
   base::FilePath path_;
 
   // Defines the set of URLs in the extension's web content.
   URLPatternSet extent_;
 
   // The parser for the manifest's permissions. This is NULL anytime not during
   // initialization.
   // TODO(rdevlin.cronin): This doesn't really belong here.
-  scoped_ptr<PermissionsParser> permissions_parser_;
+  std::unique_ptr<PermissionsParser> permissions_parser_;
 
   // The active permissions for the extension.
-  scoped_ptr<PermissionsData> permissions_data_;
+  std::unique_ptr<PermissionsData> permissions_data_;
 
   // Any warnings that occurred when trying to create/parse the extension.
   std::vector<InstallWarning> install_warnings_;
 
   // The base extension url for the extension.
   GURL extension_url_;
 
   // The extension's version.
-  scoped_ptr<base::Version> version_;
+  std::unique_ptr<base::Version> version_;
 
   // The extension's user visible version name.
   std::string version_name_;
 
   // An optional longer description of the extension.
   std::string description_;
 
   // True if the extension was generated from a user script. (We show slightly
   // different UI if so).
   bool converted_from_user_script_;
 
   // The public key used to sign the contents of the crx package.
   std::string public_key_;
 
   // The manifest from which this extension was created.
-  scoped_ptr<Manifest> manifest_;
+  std::unique_ptr<Manifest> manifest_;
 
   // Stored parsed manifest data.
-  using ManifestDataMap = std::map<std::string, scoped_ptr<ManifestData>>;
+  using ManifestDataMap = std::map<std::string, std::unique_ptr<ManifestData>>;
   ManifestDataMap manifest_data_;
 
   // Set to true at the end of InitValue when initialization is finished.
   bool finished_parsing_manifest_;
 
   // Ensures that any call to GetManifestData() prior to finishing
   // initialization happens from the same thread (this can happen when certain
   // parts of the initialization process need information from previous parts).
   base::ThreadChecker thread_checker_;
 
@@ skipping 19 matching lines @@
 typedef std::vector<ExtensionId> ExtensionIdList;
 
 // Handy struct to pass core extension info around.
 struct ExtensionInfo {
   ExtensionInfo(const base::DictionaryValue* manifest,
                 const ExtensionId& id,
                 const base::FilePath& path,
                 Manifest::Location location);
   ~ExtensionInfo();
 
-  scoped_ptr<base::DictionaryValue> extension_manifest;
+  std::unique_ptr<base::DictionaryValue> extension_manifest;
   ExtensionId extension_id;
   base::FilePath extension_path;
   Manifest::Location extension_location;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionInfo);
 };
 
 struct InstalledExtensionInfo {
   // The extension being installed - this should always be non-NULL.
@@ skipping 57 matching lines @@
   const PermissionSet& permissions;
 
   UpdatedExtensionPermissionsInfo(const Extension* extension,
                                   const PermissionSet& permissions,
                                   Reason reason);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_EXTENSION_H_