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

storage/browser/blob/blob_storage_context.cc

 // Copyright (c) 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 "storage/browser/blob/blob_storage_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "storage/browser/blob/blob_data_builder.h"
@@ skipping 46 matching lines @@
 
 BlobStorageContext::~BlobStorageContext() {
   STLDeleteContainerPairSecondPointers(blob_map_.begin(), blob_map_.end());
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID(
     const std::string& uuid) {
   scoped_ptr<BlobDataHandle> result;
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
-    return result.Pass();
+    return result;
   auto* entry = found->second;
   if (entry->flags & EXCEEDED_MEMORY)
-    return result.Pass();
+    return result;
   DCHECK(!entry->IsBeingBuilt());
   result.reset(new BlobDataHandle(uuid, entry->data->content_type(),
                                   entry->data->content_disposition(), this,
                                   base::ThreadTaskRunnerHandle::Get().get()));
-  return result.Pass();
+  return result;
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL(
     const GURL& url) {
   BlobURLMap::iterator found =
       public_blob_urls_.find(BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
   if (found == public_blob_urls_.end())
     return scoped_ptr<BlobDataHandle>();
   return GetBlobDataFromUUID(found->second);
 }
@@ skipping 15 matching lines @@
                                  target_blob_builder)) {
       BlobEntryExceededMemory(entry);
       break;
     }
   }
 
   FinishBuildingBlob(external_builder.uuid_, external_builder.content_type_);
   scoped_ptr<BlobDataHandle> handle =
       GetBlobDataFromUUID(external_builder.uuid_);
   DecrementBlobRefCount(external_builder.uuid_);
-  return handle.Pass();
+  return handle;
 }
 
 scoped_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob(
     const BlobDataBuilder* builder) {
   DCHECK(builder);
   return AddFinishedBlob(*builder);
 }
 
 bool BlobStorageContext::RegisterPublicBlobURL(const GURL& blob_url,
                                                const std::string& uuid) {
@@ skipping 133 matching lines @@
     const std::string& uuid,
     const DataElement& ipc_data) {
   scoped_refptr<BlobDataItem> blob_item;
 
   uint64_t length = ipc_data.length();
   scoped_ptr<DataElement> element(new DataElement());
   switch (ipc_data.type()) {
     case DataElement::TYPE_BYTES:
       DCHECK(!ipc_data.offset());
       element->SetToBytes(ipc_data.bytes(), length);
-      blob_item = new BlobDataItem(element.Pass());
+      blob_item = new BlobDataItem(std::move(element));
       break;
     case DataElement::TYPE_FILE:
       element->SetToFilePathRange(ipc_data.path(), ipc_data.offset(), length,
                                   ipc_data.expected_modification_time());
       blob_item = new BlobDataItem(
-          element.Pass(), ShareableFileReference::Get(ipc_data.path()));
+          std::move(element), ShareableFileReference::Get(ipc_data.path()));
       break;
     case DataElement::TYPE_FILE_FILESYSTEM:
       element->SetToFileSystemUrlRange(ipc_data.filesystem_url(),
                                        ipc_data.offset(), length,
                                        ipc_data.expected_modification_time());
-      blob_item = new BlobDataItem(element.Pass());
+      blob_item = new BlobDataItem(std::move(element));
       break;
     case DataElement::TYPE_BLOB:
       // This is a temporary item that will be deconstructed later.
       element->SetToBlobRange(ipc_data.blob_uuid(), ipc_data.offset(),
                               ipc_data.length());
-      blob_item = new BlobDataItem(element.Pass());
+      blob_item = new BlobDataItem(std::move(element));
       break;
     case DataElement::TYPE_DISK_CACHE_ENTRY:  // This type can't be sent by IPC.
       NOTREACHED();
       break;
     default:
       NOTREACHED();
       break;
   }
 
   return blob_item;
@@ skipping 135 matching lines @@
                              new_length / 1024);
         if (memory_usage_ + new_length > kMaxMemoryUsage) {
           return false;
         }
         DCHECK(!item.offset());
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToBytes(item.bytes() + offset,
                             static_cast<int64_t>(new_length));
         memory_usage_ += new_length;
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid, new BlobDataItem(element.Pass())));
+            target_blob_uuid, new BlobDataItem(std::move(element))));
       } break;
       case DataElement::TYPE_FILE: {
         DCHECK_NE(item.length(), std::numeric_limits<uint64_t>::max())
             << "We cannot use a section of a file with an unknown length";
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFilePathRange(item.path(), item.offset() + offset,
                                     new_length,
                                     item.expected_modification_time());
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid,
-            new BlobDataItem(element.Pass(), item.data_handle_)));
+            new BlobDataItem(std::move(element), item.data_handle_)));
       } break;
       case DataElement::TYPE_FILE_FILESYSTEM: {
         UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem",
                              new_length / 1024);
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToFileSystemUrlRange(item.filesystem_url(),
                                          item.offset() + offset, new_length,
                                          item.expected_modification_time());
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
-            target_blob_uuid, new BlobDataItem(element.Pass())));
+            target_blob_uuid, new BlobDataItem(std::move(element))));
       } break;
       case DataElement::TYPE_DISK_CACHE_ENTRY: {
         scoped_ptr<DataElement> element(new DataElement());
         element->SetToDiskCacheEntryRange(item.offset() + offset,
                                           new_length);
         target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem(
             target_blob_uuid,
-            new BlobDataItem(element.Pass(), item.data_handle_,
+            new BlobDataItem(std::move(element), item.data_handle_,
                              item.disk_cache_entry(),
                              item.disk_cache_stream_index())));
       } break;
       default:
         CHECK(false) << "Illegal blob item type: " << item.type();
     }
     length -= new_length;
     offset = 0;
   }
   return true;
 }
 
 bool BlobStorageContext::IsInUse(const std::string& uuid) {
   return blob_map_.find(uuid) != blob_map_.end();
 }
 
 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) {
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
     return false;
   return found->second->IsBeingBuilt();
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace storage