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

extensions/common/manifest_test.h

 // Copyright (c) 2012 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_MANIFEST_TEST_H_
 #define EXTENSIONS_COMMON_MANIFEST_TEST_H_
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 class FilePath;
 }
 
 namespace extensions {
 
 // Base class for tests that parse a manifest file.
 class ManifestTest : public testing::Test {
  public:
   ManifestTest();
   ~ManifestTest() override;
 
  protected:
   // Helper class that simplifies creating methods that take either a filename
   // to a manifest or the manifest itself.
   class ManifestData {
    public:
     explicit ManifestData(const char* name);
     ManifestData(base::DictionaryValue* manifest, const char* name);
-    explicit ManifestData(scoped_ptr<base::DictionaryValue> manifest);
-    explicit ManifestData(scoped_ptr<base::DictionaryValue> manifest,
+    explicit ManifestData(std::unique_ptr<base::DictionaryValue> manifest);
+    explicit ManifestData(std::unique_ptr<base::DictionaryValue> manifest,
                           const char* name);
     // C++98 requires the copy constructor for a type to be visible if you
     // take a const-ref of a temporary for that type.  Since Manifest
     // contains a scoped_ptr, its implicit copy constructor is declared
     // Manifest(Manifest&) according to spec 12.8.5.  This breaks the first
     // requirement and thus you cannot use it with LoadAndExpectError() or
     // LoadAndExpectSuccess() easily.
     //
     // To get around this spec pedantry, we declare the copy constructor
     // explicitly.  It will never get invoked.
     ManifestData(const ManifestData& m);
 
     ~ManifestData();
 
     const std::string& name() const { return name_; };
 
     base::DictionaryValue* GetManifest(base::FilePath manifest_path,
                                        std::string* error) const;
 
    private:
     const std::string name_;
     mutable base::DictionaryValue* manifest_;
-    mutable scoped_ptr<base::DictionaryValue> manifest_holder_;
+    mutable std::unique_ptr<base::DictionaryValue> manifest_holder_;
   };
 
   // Allows the test implementation to override a loaded test manifest's
   // extension ID. Useful for testing features behind a whitelist.
   virtual std::string GetTestExtensionID() const;
 
   // Returns the path in which to find test manifest data files, for example
   // extensions/test/data/manifest_tests.
   virtual base::FilePath GetTestDataDir();
 
-  scoped_ptr<base::DictionaryValue> LoadManifest(
-      char const* manifest_name,
-      std::string* error);
+  std::unique_ptr<base::DictionaryValue> LoadManifest(char const* manifest_name,
+                                                      std::string* error);
 
   scoped_refptr<extensions::Extension> LoadExtension(
       const ManifestData& manifest,
       std::string* error,
       extensions::Manifest::Location location =
           extensions::Manifest::INTERNAL,
       int flags = extensions::Extension::NO_FLAGS);
 
   scoped_refptr<extensions::Extension> LoadAndExpectSuccess(
       const ManifestData& manifest,
@@ skipping 78 matching lines @@
 
   bool enable_apps_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ManifestTest);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_MANIFEST_TEST_H_