Change the API of disk_cache::CreateCacheBackend to use scoped_ptr

webkit/browser/appcache/appcache_disk_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 "webkit/browser/appcache/appcache_disk_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 
 namespace appcache {
 
 // A callback shim that provides storage for the 'backend_ptr' value
 // and will delete a resulting ptr if completion occurs after its
 // been canceled.
 class AppCacheDiskCache::CreateBackendCallbackShim
     : public base::RefCounted<CreateBackendCallbackShim> {
  public:
   explicit CreateBackendCallbackShim(AppCacheDiskCache* object)
-      : backend_ptr_(NULL), appcache_diskcache_(object) {
+      : appcache_diskcache_(object) {
   }
 
   void Cancel() {
     appcache_diskcache_ = NULL;
   }
 
   void Callback(int rv) {
     if (appcache_diskcache_)
       appcache_diskcache_->OnCreateBackendComplete(rv);
   }
 
-  disk_cache::Backend* backend_ptr_;  // Accessed directly.
+  scoped_ptr<disk_cache::Backend> backend_ptr_;  // Accessed directly.
 
  private:
   friend class base::RefCounted<CreateBackendCallbackShim>;
 
   ~CreateBackendCallbackShim() {
-    delete backend_ptr_;
   }
 
   AppCacheDiskCache* appcache_diskcache_;  // Unowned pointer.
 };
 
 // An implementation of AppCacheDiskCacheInterface::Entry that's a thin
 // wrapper around disk_cache::Entry.
 class AppCacheDiskCache::EntryImpl : public Entry {
  public:
   explicit EntryImpl(disk_cache::Entry* disk_cache_entry)
@@ skipping 224 matching lines @@
                  create_backend_callback_));
   if (rv == net::ERR_IO_PENDING)
     init_callback_ = callback;
   else
     OnCreateBackendComplete(rv);
   return rv;
 }
 
 void AppCacheDiskCache::OnCreateBackendComplete(int rv) {
   if (rv == net::OK) {
-    disk_cache_.reset(create_backend_callback_->backend_ptr_);
-    create_backend_callback_->backend_ptr_ = NULL;
+    disk_cache_ = create_backend_callback_->backend_ptr_.Pass();
   }
   create_backend_callback_ = NULL;
 
   // Invoke our clients callback function.
   if (!init_callback_.is_null()) {
     init_callback_.Run(rv);
     init_callback_.Reset();
   }
 
   // Service pending calls that were queued up while we were initializing.
@@ skipping 14 matching lines @@
         NOTREACHED();
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }
 
 }  // namespace appcache