Change the API of disk_cache::CreateCacheBackend to use scoped_ptr

net/http/http_cache.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 "net/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 55 matching lines @@
 
 HttpCache::DefaultBackend::~DefaultBackend() {}
 
 // static
 HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) {
   return new DefaultBackend(MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT,
                             base::FilePath(), max_bytes, NULL);
 }
 
 int HttpCache::DefaultBackend::CreateBackend(
-    NetLog* net_log, disk_cache::Backend** backend,
+    NetLog* net_log, scoped_ptr<disk_cache::Backend>* backend,
     const CompletionCallback& callback) {
   DCHECK_GE(max_bytes_, 0);
   return disk_cache::CreateCacheBackend(type_,
                                         backend_type_,
                                         path_,
                                         max_bytes_,
                                         true,
                                         thread_.get(),
                                         net_log,
                                         backend,
@@ skipping 14 matching lines @@
     disk_entry->Close();
     disk_entry = NULL;
   }
 }
 
 //-----------------------------------------------------------------------------
 
 // This structure keeps track of work items that are attempting to create or
 // open cache entries or the backend itself.
 struct HttpCache::PendingOp {
-  PendingOp() : disk_entry(NULL), backend(NULL), writer(NULL) {}
+  PendingOp() : disk_entry(NULL), writer(NULL) {}
   ~PendingOp() {}
 
   disk_cache::Entry* disk_entry;
-  disk_cache::Backend* backend;
+  scoped_ptr<disk_cache::Backend> backend;
   WorkItem* writer;
   CompletionCallback callback;  // BackendCallback.
   WorkItemList pending_queue;
 };
 
 //-----------------------------------------------------------------------------
 
 // The type of operation represented by a work item.
 enum WorkItemOperation {
   WI_CREATE_BACKEND,
@@ skipping 978 matching lines @@
   }
 }
 
 void HttpCache::OnBackendCreated(int result, PendingOp* pending_op) {
   scoped_ptr<WorkItem> item(pending_op->writer);
   WorkItemOperation op = item->operation();
   DCHECK_EQ(WI_CREATE_BACKEND, op);
 
   // We don't need the callback anymore.
   pending_op->callback.Reset();
-  disk_cache::Backend* backend = pending_op->backend;
+  scoped_ptr<disk_cache::Backend> backend = pending_op->backend.Pass();
 
   if (backend_factory_.get()) {
     // We may end up calling OnBackendCreated multiple times if we have pending
     // work items. The first call saves the backend and releases the factory,
     // and the last call clears building_backend_.
     backend_factory_.reset();  // Reclaim memory.
     if (result == OK)
-      disk_cache_.reset(backend);
+      disk_cache_ = backend.Pass();

[rvargas (doing something else), 2013/07/26 21:05:01]

pending_op->backend.Pass() and remove |backend|

[qsr, 2013/07/29 08:26:28]

Done.

   }
 
   if (!pending_op->pending_queue.empty()) {
     WorkItem* pending_item = pending_op->pending_queue.front();
     pending_op->pending_queue.pop_front();
     DCHECK_EQ(WI_CREATE_BACKEND, pending_item->operation());
 
     // We want to process a single callback at a time, because the cache may
     // go away from the callback.
     pending_op->writer = pending_item;
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &HttpCache::OnBackendCreated, AsWeakPtr(), result, pending_op));
   } else {
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
-  if (!item->DoCallback(result, backend))
+  if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net