Convert Pass()→std::move() in //content/browser

content/browser/fileapi/file_writer_delegate_unittest.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 <stdint.h>
-
 #include <limits>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 258 matching lines @@
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, std::numeric_limits<int64_t>::max());
 
   Result result;
   ASSERT_EQ(0, usage());
-  file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+  file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kDataSize, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
   EXPECT_EQ(kDataSize, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   const GURL kBlobURL("blob:just");
   content_ = kData;
   const int64_t kAllowedGrowth = kDataSize;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
-  file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+  file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) {
   const GURL kBlobURL("blob:failure");
   content_ = kData;
   const int64_t kAllowedGrowth = kDataSize - 1;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
-  file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+  file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   const GURL kBlobURL("blob:zero");
   content_ = "";
   int64_t kAllowedGrowth = 0;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
-  file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+  file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   base::MessageLoop::current()->Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
@@ skipping 14 matching lines @@
   PrepareForWrite("test", kBlobURL, 0, std::numeric_limits<int64_t>::max());
 
   // Credate another FileWriterDelegate for concurrent write.
   file_writer_delegate2.reset(
       CreateWriterDelegate("test2", 0, std::numeric_limits<int64_t>::max()));
   request2 = empty_context_.CreateRequest(
       kBlobURL2, net::DEFAULT_PRIORITY, file_writer_delegate2.get());
 
   Result result, result2;
   ASSERT_EQ(0, usage());
-  file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
-  file_writer_delegate2->Start(request2.Pass(), GetWriteCallback(&result2));
+  file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
+  file_writer_delegate2->Start(std::move(request2), GetWriteCallback(&result2));
   base::MessageLoop::current()->Run();
   if (result.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING ||
       result2.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING)
     base::MessageLoop::current()->Run();
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status());
   file_writer_delegate_.reset();
   file_writer_delegate2.reset();
 
@@ skipping 12 matching lines @@
 
   // Writing kDataSize (=45) bytes data while allowed_growth is 100.
   int64_t offset = 0;
   int64_t allowed_growth = 100;
   ASSERT_LT(kDataSize, allowed_growth);
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     ASSERT_EQ(0, usage());
-    file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+    file_writer_delegate_->Start(std::move(request_),
+                                 GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     ASSERT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite kDataSize bytes data while allowed_growth is 20.
   offset = 0;
   allowed_growth = 20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
-    file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+    file_writer_delegate_->Start(std::move(request_),
+                                 GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     EXPECT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   }
 
   // Trying to write kDataSize bytes data from offset 25 while
   // allowed_growth is 55.
   offset = 25;
   allowed_growth = 55;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
-    file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+    file_writer_delegate_->Start(std::move(request_),
+                                 GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(offset + kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data while allowed_growth is -20.
   offset = 0;
   allowed_growth = -20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
   int64_t pre_write_usage = GetFileSizeOnDisk("test");
 
   {
     Result result;
-    file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+    file_writer_delegate_->Start(std::move(request_),
+                                 GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data with offset pre_write_usage - 20,
   // while allowed_growth is 10.
   const int kOverlap = 20;
   offset = pre_write_usage - kOverlap;
   allowed_growth = 10;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
-    file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
+    file_writer_delegate_->Start(std::move(request_),
+                                 GetWriteCallback(&result));
     base::MessageLoop::current()->Run();
     ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
     EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   }
 }
 
 }  // namespace content