Convert //url to use std::unique_ptr

content/child/webblobregistry_impl.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 "content/child/webblobregistry_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/blob_storage/blob_consolidation.h"
 #include "content/child/blob_storage/blob_transport_controller.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "storage/common/blob_storage/blob_storage_constants.h"
@@ skipping 30 matching lines @@
 blink::WebBlobRegistry::Builder* WebBlobRegistryImpl::createBuilder(
     const blink::WebString& uuid,
     const blink::WebString& content_type) {
   return new BuilderImpl(uuid, content_type, sender_.get(), io_runner_,
                          main_runner_);
 }
 
 void WebBlobRegistryImpl::registerBlobData(const blink::WebString& uuid,
                                            const blink::WebBlobData& data) {
   TRACE_EVENT0("Blob", "Registry::RegisterBlob");
-  scoped_ptr<Builder> builder(createBuilder(uuid, data.contentType()));
+  std::unique_ptr<Builder> builder(createBuilder(uuid, data.contentType()));
 
   // This is temporary until we move to createBuilder() as our blob creation
   // method.
   size_t i = 0;
   WebBlobData::Item data_item;
   while (data.itemAt(i++, data_item)) {
     if (data_item.length == 0) {
       continue;
     }
     switch (data_item.type) {
@@ skipping 67 matching lines @@
     return;
   if (length < storage::kBlobStorageIPCThresholdBytes) {
     DataElement item;
     item.SetToBytes(data, length);
     sender_->Send(new StreamHostMsg_AppendBlobDataItem(url, item));
   } else {
     // We handle larger amounts of data via SharedMemory instead of
     // writing it directly to the IPC channel.
     size_t shared_memory_size =
         std::min(length, storage::kBlobStorageMaxSharedMemoryBytes);
-    scoped_ptr<base::SharedMemory> shared_memory(
+    std::unique_ptr<base::SharedMemory> shared_memory(
         ChildThreadImpl::AllocateSharedMemory(shared_memory_size,
                                               sender_.get()));
     CHECK(shared_memory.get());
     if (!shared_memory->Map(shared_memory_size))
       CHECK(false);
 
     size_t remaining_bytes = length;
     const char* current_ptr = data;
     while (remaining_bytes) {
       size_t chunk_size = std::min(remaining_bytes, shared_memory_size);
@@ skipping 78 matching lines @@
       uuid_, content_type_, "", consolidation_->referenced_blobs()));
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WebBlobRegistryImpl::StartBlobAsyncConstruction, uuid_,
                  base::Passed(&consolidation_), sender_, main_runner_));
 }
 
 /* static */
 void WebBlobRegistryImpl::StartBlobAsyncConstruction(
     const std::string& uuid,
-    scoped_ptr<BlobConsolidation> consolidation,
+    std::unique_ptr<BlobConsolidation> consolidation,
     scoped_refptr<ThreadSafeSender> sender,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
   BlobTransportController::GetInstance()->InitiateBlobTransfer(
       uuid, std::move(consolidation), sender.get(), std::move(main_runner));
 }
 
 }  // namespace content