Convert Pass()→std::move() in //storage

storage/browser/fileapi/obfuscated_file_util.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 "storage/browser/fileapi/obfuscated_file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 263 matching lines @@
 
 base::File ObfuscatedFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FileSystemURL& url, int file_flags) {
   base::File file = CreateOrOpenInternal(context, url, file_flags);
   if (file.IsValid() && file_flags & base::File::FLAG_WRITE &&
       context->quota_limit_type() == storage::kQuotaLimitTypeUnlimited &&
       sandbox_delegate_) {
     sandbox_delegate_->StickyInvalidateUsageCache(url.origin(), url.type());
   }
-  return file.Pass();
+  return file;
 }
 
 base::File::Error ObfuscatedFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool* created) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true);
   if (!db)
     return base::File::FILE_ERROR_FAILED;
 
@@ skipping 762 matching lines @@
 
   if (base::PathExists(dest_local_path)) {
     if (!base::DeleteFile(dest_local_path, false /* recursive */))
       return base::File(base::File::FILE_ERROR_FAILED);
     LOG(WARNING) << "A stray file detected";
     InvalidateUsageCache(context, dest_url.origin(), dest_url.type());
   }
 
   base::File file = NativeFileUtil::CreateOrOpen(dest_local_path, file_flags);
   if (!file.IsValid())
-    return file.Pass();
+    return file;
 
   if (!file.created()) {
     file.Close();
     base::DeleteFile(dest_local_path, false /* recursive */);
     return base::File(base::File::FILE_ERROR_FAILED);
   }
 
   error = CommitCreateFile(root, dest_local_path, db, dest_file_info);
   if (error != base::File::FILE_OK) {
     file.Close();
     base::DeleteFile(dest_local_path, false /* recursive */);
     return base::File(error);
   }
 
-  return file.Pass();
+  return file;
 }
 
 base::File::Error ObfuscatedFileUtil::CreateFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url,
     FileInfo* dest_file_info) {
   SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true);
 
   base::FilePath root, dest_local_path;
@@ skipping 274 matching lines @@
 
     int64_t growth = UsageForPath(file_info.name.size());
     if (!AllocateQuota(context, growth))
       return base::File(base::File::FILE_ERROR_NO_SPACE);
     base::File file = CreateAndOpenFile(context, url, &file_info, file_flags);
     if (file.IsValid()) {
       UpdateUsage(context, url, growth);
       context->change_observers()->Notify(
           &FileChangeObserver::OnCreateFile, base::MakeTuple(url));
     }
-    return file.Pass();
+    return file;
   }
 
   if (file_flags & base::File::FLAG_CREATE)
     return base::File(base::File::FILE_ERROR_EXISTS);
 
   base::File::Info platform_file_info;
   base::FilePath local_path;
   FileInfo file_info;
   base::File::Error error = GetFileInfoInternal(
       db, context, url, file_id, &file_info, &platform_file_info, &local_path);
@@ skipping 13 matching lines @@
   base::File file = NativeFileUtil::CreateOrOpen(local_path, file_flags);
   if (!file.IsValid()) {
     error = file.error_details();
     if (error == base::File::FILE_ERROR_NOT_FOUND) {
       // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
       // TODO(tzik): Delete database entry after ensuring the file lost.
       InvalidateUsageCache(context, url.origin(), url.type());
       LOG(WARNING) << "Lost a backing file.";
       return base::File(base::File::FILE_ERROR_FAILED);
     }
-    return file.Pass();
+    return file;
   }
 
   // If truncating we need to update the usage.
   if (delta) {
     UpdateUsage(context, url, delta);
     context->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, base::MakeTuple(url));
   }
-  return file.Pass();
+  return file;
 }
 
 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) {
   return special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin);
 }
 
 }  // namespace storage