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

chrome/browser/chromeos/file_manager/file_browser_handlers.cc

 // 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.
 
 #include "chrome/browser/chromeos/file_manager/file_browser_handlers.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <set>
 #include <utility>
@@ skipping 161 matching lines @@
   // Executes the task for each file. |done| will be run with the result.
   void Execute(const std::vector<FileSystemURL>& file_urls,
                const file_tasks::FileTaskFinishedCallback& done);
 
  private:
   // This object is responsible to delete itself.
   virtual ~FileBrowserHandlerExecutor();
 
   // Checks legitimacy of file url and grants file RO access permissions from
   // handler (target) extension and its renderer process.
-  static scoped_ptr<FileDefinitionList> SetupFileAccessPermissions(
+  static std::unique_ptr<FileDefinitionList> SetupFileAccessPermissions(
       scoped_refptr<storage::FileSystemContext> file_system_context_handler,
       const scoped_refptr<const Extension>& handler_extension,
       const std::vector<FileSystemURL>& file_urls);
 
   void ExecuteDoneOnUIThread(bool success);
-  void ExecuteAfterSetupFileAccess(scoped_ptr<FileDefinitionList> file_list);
+  void ExecuteAfterSetupFileAccess(
+      std::unique_ptr<FileDefinitionList> file_list);
   void ExecuteFileActionsOnUIThread(
-      scoped_ptr<FileDefinitionList> file_definition_list,
-      scoped_ptr<EntryDefinitionList> entry_definition_list);
+      std::unique_ptr<FileDefinitionList> file_definition_list,
+      std::unique_ptr<EntryDefinitionList> entry_definition_list);
   void SetupPermissionsAndDispatchEvent(
-      scoped_ptr<FileDefinitionList> file_definition_list,
-      scoped_ptr<EntryDefinitionList> entry_definition_list,
+      std::unique_ptr<FileDefinitionList> file_definition_list,
+      std::unique_ptr<EntryDefinitionList> entry_definition_list,
       int handler_pid_in,
       extensions::ExtensionHost* host);
 
   // Registers file permissions from |handler_host_permissions_| with
   // ChildProcessSecurityPolicy for process with id |handler_pid|.
   void SetupHandlerHostFileAccessPermissions(
       FileDefinitionList* file_definition_list,
       const Extension* extension,
       int handler_pid);
 
   Profile* profile_;
   scoped_refptr<const Extension> extension_;
   const std::string action_id_;
   file_tasks::FileTaskFinishedCallback done_;
   base::WeakPtrFactory<FileBrowserHandlerExecutor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileBrowserHandlerExecutor);
 };
 
 // static
-scoped_ptr<FileDefinitionList>
+std::unique_ptr<FileDefinitionList>
 FileBrowserHandlerExecutor::SetupFileAccessPermissions(
     scoped_refptr<storage::FileSystemContext> file_system_context_handler,
     const scoped_refptr<const Extension>& handler_extension,
     const std::vector<FileSystemURL>& file_urls) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(handler_extension.get());
 
   storage::ExternalFileSystemBackend* backend =
       file_system_context_handler->external_backend();
 
-  scoped_ptr<FileDefinitionList> file_definition_list(new FileDefinitionList);
+  std::unique_ptr<FileDefinitionList> file_definition_list(
+      new FileDefinitionList);
   for (size_t i = 0; i < file_urls.size(); ++i) {
     const FileSystemURL& url = file_urls[i];
 
     // Check if this file system entry exists first.
     base::File::Info file_info;
 
     base::FilePath local_path = url.path();
     base::FilePath virtual_path = url.virtual_path();
 
     const bool is_drive_file = url.type() == storage::kFileSystemTypeDrive;
@@ skipping 56 matching lines @@
       FROM_HERE,
       base::Bind(&SetupFileAccessPermissions,
                  file_system_context,
                  extension_,
                  file_urls),
       base::Bind(&FileBrowserHandlerExecutor::ExecuteAfterSetupFileAccess,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FileBrowserHandlerExecutor::ExecuteAfterSetupFileAccess(
-    scoped_ptr<FileDefinitionList> file_definition_list) {
+    std::unique_ptr<FileDefinitionList> file_definition_list) {
   // Outlives the conversion process, since bound to the callback.
   const FileDefinitionList& file_definition_list_ref =
       *file_definition_list.get();
   file_manager::util::ConvertFileDefinitionListToEntryDefinitionList(
       profile_,
       extension_->id(),
       file_definition_list_ref,
       base::Bind(&FileBrowserHandlerExecutor::ExecuteFileActionsOnUIThread,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&file_definition_list)));
 }
 
 void FileBrowserHandlerExecutor::ExecuteDoneOnUIThread(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!done_.is_null())
     done_.Run(
         success
             ? extensions::api::file_manager_private::TASK_RESULT_MESSAGE_SENT
             : extensions::api::file_manager_private::TASK_RESULT_FAILED);
   delete this;
 }
 
 void FileBrowserHandlerExecutor::ExecuteFileActionsOnUIThread(
-    scoped_ptr<FileDefinitionList> file_definition_list,
-    scoped_ptr<EntryDefinitionList> entry_definition_list) {
+    std::unique_ptr<FileDefinitionList> file_definition_list,
+    std::unique_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (file_definition_list->empty() || entry_definition_list->empty()) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   int handler_pid = ExtractProcessFromExtensionId(profile_, extension_->id());
   if (handler_pid <= 0 &&
       !extensions::BackgroundInfo::HasLazyBackgroundPage(extension_.get())) {
@@ skipping 17 matching lines @@
         profile_, extension_->id(),
         base::Bind(
             &FileBrowserHandlerExecutor::SetupPermissionsAndDispatchEvent,
             weak_ptr_factory_.GetWeakPtr(),
             base::Passed(std::move(file_definition_list)),
             base::Passed(std::move(entry_definition_list)), handler_pid));
   }
 }
 
 void FileBrowserHandlerExecutor::SetupPermissionsAndDispatchEvent(
-    scoped_ptr<FileDefinitionList> file_definition_list,
-    scoped_ptr<EntryDefinitionList> entry_definition_list,
+    std::unique_ptr<FileDefinitionList> file_definition_list,
+    std::unique_ptr<EntryDefinitionList> entry_definition_list,
     int handler_pid_in,
     extensions::ExtensionHost* host) {
   int handler_pid = host ? host->render_process_host()->GetID() :
       handler_pid_in;
 
   if (handler_pid <= 0) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   extensions::EventRouter* router = extensions::EventRouter::Get(profile_);
   if (!router) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   SetupHandlerHostFileAccessPermissions(
       file_definition_list.get(), extension_.get(), handler_pid);
 
-  scoped_ptr<base::ListValue> event_args(new base::ListValue());
+  std::unique_ptr<base::ListValue> event_args(new base::ListValue());
   event_args->Append(new base::StringValue(action_id_));
   base::DictionaryValue* details = new base::DictionaryValue();
   event_args->Append(details);
   // Get file definitions. These will be replaced with Entry instances by
   // dispatchEvent() method from event_binding.js.
   base::ListValue* file_entries = new base::ListValue();
   details->Set("entries", file_entries);
 
   for (EntryDefinitionList::const_iterator iter =
            entry_definition_list->begin();
        iter != entry_definition_list->end();
        ++iter) {
     base::DictionaryValue* file_def = new base::DictionaryValue();
     file_entries->Append(file_def);
     file_def->SetString("fileSystemName", iter->file_system_name);
     file_def->SetString("fileSystemRoot", iter->file_system_root_url);
     file_def->SetString("fileFullPath",
                         "/" + iter->full_path.AsUTF8Unsafe());
     file_def->SetBoolean("fileIsDirectory", iter->is_directory);
   }
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+  std::unique_ptr<extensions::Event> event(new extensions::Event(
       extensions::events::FILE_BROWSER_HANDLER_ON_EXECUTE,
       "fileBrowserHandler.onExecute", std::move(event_args)));
   event->restrict_to_browser_context = profile_;
   router->DispatchEventToExtension(extension_->id(), std::move(event));
 
   ExecuteDoneOnUIThread(true);
 }
 
 void FileBrowserHandlerExecutor::SetupHandlerHostFileAccessPermissions(
     FileDefinitionList* file_definition_list,
@@ skipping 106 matching lines @@
       if (common_handlers.empty())
         return FileBrowserHandlerList();
     }
   }
 
   return common_handlers;
 }
 
 }  // namespace file_browser_handlers
 }  // namespace file_manager