Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/file_system_provider/service_unittest.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 "chrome/browser/chromeos/file_system_provider/service.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/registry_interface.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/common/extensions/api/file_system_provider_capabilities/file_system_provider_capabilities_handler.h"
 #include "chrome/test/base/testing_browser_process.h"
@@ skipping 87 matching lines @@
                         const std::string& file_system_id) override {
     if (!file_system_info_.get() || !watchers_.get())
       return;
     if (file_system_info_->extension_id() == extension_id &&
         file_system_info_->file_system_id() == file_system_id) {
       file_system_info_.reset();
       watchers_.reset();
     }
   }
 
-  scoped_ptr<RestoredFileSystems> RestoreFileSystems(
+  std::unique_ptr<RestoredFileSystems> RestoreFileSystems(
       const std::string& extension_id) override {
-    scoped_ptr<RestoredFileSystems> result(new RestoredFileSystems);
+    std::unique_ptr<RestoredFileSystems> result(new RestoredFileSystems);
 
     if (file_system_info_.get() && watchers_.get()) {
       RestoredFileSystem restored_file_system;
       restored_file_system.extension_id = file_system_info_->extension_id();
 
       MountOptions options;
       options.file_system_id = file_system_info_->file_system_id();
       options.display_name = file_system_info_->display_name();
       options.writable = file_system_info_->writable();
       options.supports_notify_tag = file_system_info_->supports_notify_tag();
@@ skipping 14 matching lines @@
     ASSERT_NE(watchers_->end(), it);
     it->second.last_tag = watcher.last_tag;
   }
 
   const ProvidedFileSystemInfo* file_system_info() const {
     return file_system_info_.get();
   }
   const Watchers* watchers() const { return watchers_.get(); }
 
  private:
-  scoped_ptr<ProvidedFileSystemInfo> file_system_info_;
-  scoped_ptr<Watchers> watchers_;
+  std::unique_ptr<ProvidedFileSystemInfo> file_system_info_;
+  std::unique_ptr<Watchers> watchers_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeRegistry);
 };
 
 // Creates a fake extension with the specified |extension_id|.
 scoped_refptr<extensions::Extension> CreateFakeExtension(
     const std::string& extension_id) {
   base::DictionaryValue manifest;
   std::string error;
   manifest.SetStringWithoutPathExpansion(extensions::manifest_keys::kVersion,
@@ skipping 27 matching lines @@
     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
     extension_registry_.reset(new extensions::ExtensionRegistry(profile_));
 
     service_.reset(new Service(profile_, extension_registry_.get()));
     service_->SetFileSystemFactoryForTesting(
         base::Bind(&FakeProvidedFileSystem::Create));
     extension_ = CreateFakeExtension(kExtensionId);
 
     registry_ = new FakeRegistry;
     // Passes ownership to the service instance.
-    service_->SetRegistryForTesting(make_scoped_ptr(registry_));
+    service_->SetRegistryForTesting(base::WrapUnique(registry_));
 
     fake_watcher_.entry_path = base::FilePath(FILE_PATH_LITERAL("/a/b/c"));
     fake_watcher_.recursive = true;
     fake_watcher_.last_tag = "hello-world";
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;
   FakeChromeUserManager* user_manager_;
-  scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
-  scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
-  scoped_ptr<Service> service_;
+  std::unique_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
+  std::unique_ptr<extensions::ExtensionRegistry> extension_registry_;
+  std::unique_ptr<Service> service_;
   scoped_refptr<extensions::Extension> extension_;
   FakeRegistry* registry_;  // Owned by Service.
   Watcher fake_watcher_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   EXPECT_EQ(base::File::FILE_OK,
@@ skipping 313 matching lines @@
     EXPECT_EQ(1u, observer.unmounts.size());
     EXPECT_FALSE(registry_->file_system_info());
     EXPECT_FALSE(registry_->watchers());
   }
 
   service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos