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

chrome/browser/chromeos/file_manager/fileapi_util.cc

 // Copyright 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 "chrome/browser/chromeos/file_manager/fileapi_util.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/files/file.h"
@@ skipping 57 matching lines @@
   FileDefinitionListConverter(Profile* profile,
                               const std::string& extension_id,
                               const FileDefinitionList& file_definition_list,
                               const EntryDefinitionListCallback& callback);
   ~FileDefinitionListConverter() {}
 
  private:
   // Converts the element under the iterator to an entry. First, converts
   // the virtual path to an URL, and calls OnResolvedURL(). In case of error
   // calls OnIteratorConverted with an error entry definition.
-  void ConvertNextIterator(scoped_ptr<FileDefinitionListConverter> self_deleter,
-                           FileDefinitionList::const_iterator iterator);
+  void ConvertNextIterator(
+      std::unique_ptr<FileDefinitionListConverter> self_deleter,
+      FileDefinitionList::const_iterator iterator);
 
   // Creates an entry definition from the URL as well as the file definition.
   // Then, calls OnIteratorConverted with the created entry definition.
-  void OnResolvedURL(scoped_ptr<FileDefinitionListConverter> self_deleter,
+  void OnResolvedURL(std::unique_ptr<FileDefinitionListConverter> self_deleter,
                      FileDefinitionList::const_iterator iterator,
                      base::File::Error error,
                      const storage::FileSystemInfo& info,
                      const base::FilePath& file_path,
                      storage::FileSystemContext::ResolvedEntryType type);
 
   // Called when the iterator is converted. Adds the |entry_definition| to
   // |results_| and calls ConvertNextIterator() for the next element.
-  void OnIteratorConverted(scoped_ptr<FileDefinitionListConverter> self_deleter,
-                           FileDefinitionList::const_iterator iterator,
-                           const EntryDefinition& entry_definition);
+  void OnIteratorConverted(
+      std::unique_ptr<FileDefinitionListConverter> self_deleter,
+      FileDefinitionList::const_iterator iterator,
+      const EntryDefinition& entry_definition);
 
   scoped_refptr<storage::FileSystemContext> file_system_context_;
   const std::string extension_id_;
   const FileDefinitionList file_definition_list_;
   const EntryDefinitionListCallback callback_;
-  scoped_ptr<EntryDefinitionList> result_;
+  std::unique_ptr<EntryDefinitionList> result_;
 };
 
 FileDefinitionListConverter::FileDefinitionListConverter(
     Profile* profile,
     const std::string& extension_id,
     const FileDefinitionList& file_definition_list,
     const EntryDefinitionListCallback& callback)
     : extension_id_(extension_id),
       file_definition_list_(file_definition_list),
       callback_(callback),
       result_(new EntryDefinitionList) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // File browser APIs are meant to be used only from extension context, so
   // the extension's site is the one in whose file system context the virtual
   // path should be found.
   GURL site = extensions::util::GetSiteForExtensionId(extension_id_, profile);
   file_system_context_ =
       content::BrowserContext::GetStoragePartitionForSite(
           profile, site)->GetFileSystemContext();
 
   // Deletes the converter, once the scoped pointer gets out of scope. It is
   // either, if the conversion is finished, or ResolveURL() is terminated, and
   // the callback not called because of shutdown.
-  scoped_ptr<FileDefinitionListConverter> self_deleter(this);
+  std::unique_ptr<FileDefinitionListConverter> self_deleter(this);
   ConvertNextIterator(std::move(self_deleter), file_definition_list_.begin());
 }
 
 void FileDefinitionListConverter::ConvertNextIterator(
-    scoped_ptr<FileDefinitionListConverter> self_deleter,
+    std::unique_ptr<FileDefinitionListConverter> self_deleter,
     FileDefinitionList::const_iterator iterator) {
   if (iterator == file_definition_list_.end()) {
     // The converter object will be destroyed since |self_deleter| gets out of
     // scope.
     callback_.Run(std::move(result_));
     return;
   }
 
   if (!file_system_context_.get()) {
     OnIteratorConverted(std::move(self_deleter), iterator,
@@ skipping 12 matching lines @@
   // of shutdown during ResolveURL().
   file_system_context_->ResolveURL(
       url,
       base::Bind(&FileDefinitionListConverter::OnResolvedURL,
                  base::Unretained(this),
                  base::Passed(&self_deleter),
                  iterator));
 }
 
 void FileDefinitionListConverter::OnResolvedURL(
-    scoped_ptr<FileDefinitionListConverter> self_deleter,
+    std::unique_ptr<FileDefinitionListConverter> self_deleter,
     FileDefinitionList::const_iterator iterator,
     base::File::Error error,
     const storage::FileSystemInfo& info,
     const base::FilePath& file_path,
     storage::FileSystemContext::ResolvedEntryType type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error != base::File::FILE_OK) {
     OnIteratorConverted(std::move(self_deleter), iterator,
                         CreateEntryDefinitionWithError(error));
@@ skipping 23 matching lines @@
   DCHECK(root_virtual_path == iterator->virtual_path ||
          root_virtual_path.IsParent(iterator->virtual_path));
   base::FilePath full_path;
   root_virtual_path.AppendRelativePath(iterator->virtual_path, &full_path);
   entry_definition.full_path = full_path;
 
   OnIteratorConverted(std::move(self_deleter), iterator, entry_definition);
 }
 
 void FileDefinitionListConverter::OnIteratorConverted(
-    scoped_ptr<FileDefinitionListConverter> self_deleter,
+    std::unique_ptr<FileDefinitionListConverter> self_deleter,
     FileDefinitionList::const_iterator iterator,
     const EntryDefinition& entry_definition) {
   result_->push_back(entry_definition);
   ConvertNextIterator(std::move(self_deleter), ++iterator);
 }
 
 // Helper function to return the converted definition entry directly, without
 // the redundant container.
 void OnConvertFileDefinitionDone(
     const EntryDefinitionCallback& callback,
-    scoped_ptr<EntryDefinitionList> entry_definition_list) {
+    std::unique_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_EQ(1u, entry_definition_list->size());
   callback.Run(entry_definition_list->at(0));
 }
 
 // Checks if the |file_path| points non-native location or not.
 bool IsUnderNonNativeLocalPath(const storage::FileSystemContext& context,
                                const base::FilePath& file_path) {
   base::FilePath virtual_path;
   if (!context.external_backend()->GetVirtualPath(file_path, &virtual_path))
     return false;
 
   const storage::FileSystemURL url = context.CreateCrackedFileSystemURL(
       GURL(), storage::kFileSystemTypeExternal, virtual_path);
   if (!url.is_valid())
     return false;
 
   return IsNonNativeFileSystemType(url.type());
 }
 
 // Helper class to convert SelectedFileInfoList into ChooserFileInfoList.
 class ConvertSelectedFileInfoListToFileChooserFileInfoListImpl {
  public:
   // The scoped pointer to control lifetime of the instance itself. The pointer
   // is passed to callback functions and binds the lifetime of the instance to
   // the callback's lifetime.
-  typedef scoped_ptr<ConvertSelectedFileInfoListToFileChooserFileInfoListImpl>
+  typedef std::unique_ptr<
+      ConvertSelectedFileInfoListToFileChooserFileInfoListImpl>
       Lifetime;
 
   ConvertSelectedFileInfoListToFileChooserFileInfoListImpl(
       storage::FileSystemContext* context,
       const GURL& origin,
       const SelectedFileInfoList& selected_info_list,
       const FileChooserFileInfoListCallback& callback)
       : context_(context),
         chooser_info_list_(new FileChooserFileInfoList),
         callback_(callback) {
@@ skipping 137 matching lines @@
     chooser_info_list_.reset();
   }
 
   // Returns an empty list to the |callback_|.
   void NotifyError(Lifetime /* lifetime */) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     callback_.Run(FileChooserFileInfoList());
   }
 
   scoped_refptr<storage::FileSystemContext> context_;
-  scoped_ptr<FileChooserFileInfoList> chooser_info_list_;
+  std::unique_ptr<FileChooserFileInfoList> chooser_info_list_;
   const FileChooserFileInfoListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(
       ConvertSelectedFileInfoListToFileChooserFileInfoListImpl);
 };
 
 }  // namespace
 
 EntryDefinition::EntryDefinition() {
 }
@@ skipping 180 matching lines @@
   const storage::FileSystemURL isolated_url =
       context.CreateCrackedFileSystemURL(
           origin,
           storage::kFileSystemTypeIsolated,
           base::FilePath(isolated_file_system_id).Append(register_name));
   return isolated_url;
 }
 
 }  // namespace util
 }  // namespace file_manager