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

chrome/browser/chromeos/extensions/file_manager/private_api_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/extensions/file_manager/private_api_util.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 35 matching lines @@
 
 // The callback type for GetFileNativeLocalPathFor{Opening,Saving}. It receives
 // the resolved local path when successful, and receives empty path for failure.
 typedef base::Callback<void(const base::FilePath&)> LocalPathCallback;
 
 // Converts a callback from Drive file system to LocalPathCallback.
 void OnDriveGetFile(const base::FilePath& path,
                     const LocalPathCallback& callback,
                     drive::FileError error,
                     const base::FilePath& local_file_path,
-                    scoped_ptr<drive::ResourceEntry> entry) {
+                    std::unique_ptr<drive::ResourceEntry> entry) {
   if (error != drive::FILE_ERROR_OK)
     DLOG(ERROR) << "Failed to get " << path.value() << " with: " << error;
   callback.Run(local_file_path);
 }
 
 // Gets a resolved local file path of a non native |path| for file opening.
 void GetFileNativeLocalPathForOpening(Profile* profile,
                                       const base::FilePath& path,
                                       const LocalPathCallback& callback) {
   if (drive::util::IsUnderDriveMountPoint(path)) {
@@ skipping 29 matching lines @@
                                   base::Bind(&OnDriveGetFile, path, callback));
     return;
   }
 
   // TODO(kinaba): For now, the only writable non-local volume is Drive.
   NOTREACHED();
   callback.Run(base::FilePath());
 }
 
 // Forward declarations of helper functions for GetSelectedFileInfo().
-void ContinueGetSelectedFileInfo(Profile* profile,
-                                 scoped_ptr<GetSelectedFileInfoParams> params,
-                                 const base::FilePath& local_file_path);
+void ContinueGetSelectedFileInfo(
+    Profile* profile,
+    std::unique_ptr<GetSelectedFileInfoParams> params,
+    const base::FilePath& local_file_path);
 
 // Part of GetSelectedFileInfo().
-void GetSelectedFileInfoInternal(Profile* profile,
-                                 scoped_ptr<GetSelectedFileInfoParams> params) {
+void GetSelectedFileInfoInternal(
+    Profile* profile,
+    std::unique_ptr<GetSelectedFileInfoParams> params) {
   DCHECK(profile);
 
   for (size_t i = params->selected_files.size();
        i < params->file_paths.size(); ++i) {
     const base::FilePath& file_path = params->file_paths[i];
 
     if (file_manager::util::IsUnderNonNativeLocalPath(profile, file_path)) {
       // When the caller of the select file dialog wants local file paths, and
       // the selected path does not point to a native local path (e.g., Drive,
       // MTP, or provided file system), we should resolve the path.
@@ skipping 22 matching lines @@
       }
     } else {
       params->selected_files.push_back(
           ui::SelectedFileInfo(file_path, file_path));
     }
   }
   params->callback.Run(params->selected_files);
 }
 
 // Part of GetSelectedFileInfo().
-void ContinueGetSelectedFileInfo(Profile* profile,
-                                 scoped_ptr<GetSelectedFileInfoParams> params,
-                                 const base::FilePath& local_path) {
+void ContinueGetSelectedFileInfo(
+    Profile* profile,
+    std::unique_ptr<GetSelectedFileInfoParams> params,
+    const base::FilePath& local_path) {
   if (local_path.empty()) {
     params->callback.Run(std::vector<ui::SelectedFileInfo>());
     return;
   }
   const int index = params->selected_files.size();
   const base::FilePath& file_path = params->file_paths[index];
   params->selected_files.push_back(ui::SelectedFileInfo(file_path, local_path));
   GetSelectedFileInfoInternal(profile, std::move(params));
 }
 
@@ skipping 155 matching lines @@
 }
 
 void GetSelectedFileInfo(content::RenderFrameHost* render_frame_host,
                          Profile* profile,
                          const std::vector<GURL>& file_urls,
                          GetSelectedFileInfoLocalPathOption local_path_option,
                          GetSelectedFileInfoCallback callback) {
   DCHECK(render_frame_host);
   DCHECK(profile);
 
-  scoped_ptr<GetSelectedFileInfoParams> params(new GetSelectedFileInfoParams);
+  std::unique_ptr<GetSelectedFileInfoParams> params(
+      new GetSelectedFileInfoParams);
   params->local_path_option = local_path_option;
   params->callback = callback;
 
   for (size_t i = 0; i < file_urls.size(); ++i) {
     const GURL& file_url = file_urls[i];
     const base::FilePath path = GetLocalPathFromURL(
         render_frame_host, profile, file_url);
     if (!path.empty()) {
       DVLOG(1) << "Selected: file path: " << path.value();
       params->file_paths.push_back(path);
@@ skipping 18 matching lines @@
 }
 
 drive::EventLogger* GetLogger(Profile* profile) {
   drive::DriveIntegrationService* service =
       drive::DriveIntegrationServiceFactory::FindForProfile(profile);
   return service ? service->event_logger() : NULL;
 }
 
 }  // namespace util
 }  // namespace file_manager