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

storage/browser/blob/blob_data_builder.cc

 // Copyright (c) 2015 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/blob/blob_data_builder.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/time/time.h"
 #include "net/disk_cache/disk_cache.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 
 namespace storage {
 
 const char BlobDataBuilder::kAppendFutureFileTemporaryFileName[] =
@@ skipping 31 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 void BlobDataBuilder::AppendData(const char* data, size_t length) {
   if (!length)
     return;
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBytes(data, length);
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
 }
 
 size_t BlobDataBuilder::AppendFutureData(size_t length) {
   CHECK_NE(length, 0u);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBytesDescription(length);
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
   return items_.size() - 1;
 }
 
 bool BlobDataBuilder::PopulateFutureData(size_t index,
                                          const char* data,
                                          size_t offset,
                                          size_t length) {
   DCHECK_LT(index, items_.size());
   DCHECK(data);
   DataElement* element = items_.at(index)->data_element_ptr();
@@ skipping 22 matching lines @@
   std::memcpy(element->mutable_bytes() + offset, data, length);
   return true;
 }
 
 size_t BlobDataBuilder::AppendFutureFile(uint64_t offset, uint64_t length) {
   CHECK_NE(length, 0ull);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(base::FilePath::FromUTF8Unsafe(std::string(
                                   kAppendFutureFileTemporaryFileName)),
                               offset, length, base::Time());
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
   return items_.size() - 1;
 }
 
 bool BlobDataBuilder::PopulateFutureFile(
     size_t index,
     const scoped_refptr<ShareableFileReference>& file_reference,
     const base::Time& expected_modification_time) {
   DCHECK_LT(index, items_.size());
   DataElement* old_element = items_.at(index)->data_element_ptr();
 
   if (old_element->type() != DataElement::TYPE_FILE) {
     DVLOG(1) << "Invalid item type.";
     return false;
   } else if (old_element->path().AsUTF8Unsafe() !=
              std::string(kAppendFutureFileTemporaryFileName)) {
     DVLOG(1) << "Item not created by AppendFutureFile";
     return false;
   }
   uint64_t length = old_element->length();
   uint64_t offset = old_element->offset();
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_reference->path(), offset, length,
                               expected_modification_time);
-  items_[index] = new BlobDataItem(element.Pass(), file_reference);
+  items_[index] = new BlobDataItem(std::move(element), file_reference);
   return true;
 }
 
 void BlobDataBuilder::AppendFile(const base::FilePath& file_path,
                                  uint64_t offset,
                                  uint64_t length,
                                  const base::Time& expected_modification_time) {
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFilePathRange(file_path, offset, length,
                               expected_modification_time);
-  items_.push_back(
-      new BlobDataItem(element.Pass(), ShareableFileReference::Get(file_path)));
+  items_.push_back(new BlobDataItem(std::move(element),
+                                    ShareableFileReference::Get(file_path)));
 }
 
 void BlobDataBuilder::AppendBlob(const std::string& uuid,
                                  uint64_t offset,
                                  uint64_t length) {
   DCHECK_GT(length, 0ul);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBlobRange(uuid, offset, length);
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
 }
 
 void BlobDataBuilder::AppendBlob(const std::string& uuid) {
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToBlob(uuid);
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
 }
 
 void BlobDataBuilder::AppendFileSystemFile(
     const GURL& url,
     uint64_t offset,
     uint64_t length,
     const base::Time& expected_modification_time) {
   DCHECK_GT(length, 0ul);
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToFileSystemUrlRange(url, offset, length,
                                    expected_modification_time);
-  items_.push_back(new BlobDataItem(element.Pass()));
+  items_.push_back(new BlobDataItem(std::move(element)));
 }
 
 void BlobDataBuilder::AppendDiskCacheEntry(
     const scoped_refptr<DataHandle>& data_handle,
     disk_cache::Entry* disk_cache_entry,
     int disk_cache_stream_index) {
   scoped_ptr<DataElement> element(new DataElement());
   element->SetToDiskCacheEntryRange(
       0U, disk_cache_entry->GetDataSize(disk_cache_stream_index));
-  items_.push_back(
-      new BlobDataItem(element.Pass(), data_handle, disk_cache_entry,
-                       disk_cache_stream_index));
+  items_.push_back(new BlobDataItem(std::move(element), data_handle,
+                                    disk_cache_entry, disk_cache_stream_index));
 }
 
 void BlobDataBuilder::Clear() {
   items_.clear();
   content_disposition_.clear();
   content_type_.clear();
   uuid_.clear();
 }
 
 void PrintTo(const BlobDataBuilder& x, std::ostream* os) {
   DCHECK(os);
   *os << "<BlobDataBuilder>{uuid: " << x.uuid()
       << ", content_type: " << x.content_type_
       << ", content_disposition: " << x.content_disposition_ << ", items: [";
   for (const auto& item : x.items_) {
     PrintTo(*item, os);
     *os << ", ";
   }
   *os << "]}";
 }
 
 }  // namespace storage