Delete PNaCl translation cache backend object when no longer needed

chrome/browser/nacl_host/pnacl_translation_cache.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 "chrome/browser/nacl_host/pnacl_translation_cache.h"
 
 #include <string>
 
+#include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "components/nacl/common/pnacl_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 
@@ skipping 41 matching lines @@
   //                            --> Create --
   // Reads:
   // Start -> Open --------Read ----> Close
   //                       |  ^
   //                       |__|
   enum CacheStep {
     UNINITIALIZED,
     OPEN_ENTRY,
     CREATE_ENTRY,
     TRANSFER_ENTRY,
-    CLOSE_ENTRY
+    CLOSE_ENTRY,
+    FINISHED
   };
 
  private:
   friend class base::RefCounted<PnaclTranslationCacheEntry>;
   PnaclTranslationCacheEntry(base::WeakPtr<PnaclTranslationCache> cache,
                              const std::string& key,
                              bool is_read);
   ~PnaclTranslationCacheEntry();
 
   // Try to open an existing entry in the backend
@@ skipping 54 matching lines @@
     const std::string& key,
     bool is_read)
     : cache_(cache),
       key_(key),
       entry_(NULL),
       step_(UNINITIALIZED),
       is_read_(is_read) {}
 
 PnaclTranslationCacheEntry::~PnaclTranslationCacheEntry() {
   // Ensure we have called the user's callback
-  DCHECK(read_callback_.is_null());
-  DCHECK(write_callback_.is_null());
+  if (step_ != FINISHED) {
+    if (!read_callback_.is_null()) {
+      BrowserThread::PostTask(
+          BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(read_callback_,
+                     net::ERR_ABORTED,
+                     scoped_refptr<net::DrainableIOBuffer>()));
+    }
+    if (!write_callback_.is_null()) {
+      BrowserThread::PostTask(BrowserThread::IO,
+                              FROM_HERE,
+                              base::Bind(write_callback_, net::ERR_ABORTED));
+    }
+  }
 }
 
 void PnaclTranslationCacheEntry::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   step_ = OPEN_ENTRY;
   OpenEntry();
 }
 
 // OpenEntry, CreateEntry, WriteEntry, ReadEntry and CloseEntry are only called
 // from DispatchNext, so they know that cache_ is still valid.
@@ skipping 44 matching lines @@
   if (rv < 0) {
     LOG(ERROR) << "Failed to close entry: " << net::ErrorToString(rv);
     entry_->Doom();
   }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(&CloseDiskCacheEntry, entry_));
   Finish(rv);
 }
 
 void PnaclTranslationCacheEntry::Finish(int rv) {
+  step_ = FINISHED;
   if (is_read_) {
     if (!read_callback_.is_null()) {
-      read_callback_.Run(rv, io_buf_);
-      read_callback_.Reset();
+      BrowserThread::PostTask(BrowserThread::IO,
+                              FROM_HERE,
+                              base::Bind(read_callback_, rv, io_buf_));
     }
   } else {
     if (!write_callback_.is_null()) {
-      write_callback_.Run(rv);
-      write_callback_.Reset();
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE, base::Bind(write_callback_, rv));
     }
   }
   cache_->OpComplete(this);
 }
 
 void PnaclTranslationCacheEntry::DispatchNext(int rv) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!cache_)
     return;
 
   switch (step_) {
     case UNINITIALIZED:
+    case FINISHED:
       LOG(ERROR) << "DispatchNext called uninitialized";
       break;
 
     case OPEN_ENTRY:
       if (rv == net::OK) {
         step_ = TRANSFER_ENTRY;
         if (is_read_) {
           int bytes_to_transfer = entry_->GetDataSize(1);
           io_buf_ = new net::DrainableIOBuffer(
               new net::IOBuffer(bytes_to_transfer), bytes_to_transfer);
@@ skipping 24 matching lines @@
       } else {
         LOG(ERROR) << "Failed to Create Entry: " << net::ErrorToString(rv);
         Finish(rv);
       }
       break;
 
     case TRANSFER_ENTRY:
       if (rv < 0) {
         // We do not call DispatchNext directly if WriteEntry/ReadEntry returns
         // ERR_IO_PENDING, and the callback should not return that value either.
-        LOG(ERROR)
-            << "Failed to complete write to entry: " << net::ErrorToString(rv);
+        LOG(ERROR) << "Failed to complete write to entry: "
+                   << net::ErrorToString(rv);
         step_ = CLOSE_ENTRY;
         CloseEntry(rv);
         break;
       } else if (rv > 0) {
         io_buf_->DidConsume(rv);
         if (io_buf_->BytesRemaining() > 0) {
           is_read_
               ? ReadEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining())
               : WriteEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining());
           break;
@@ skipping 31 matching lines @@
   int rv = disk_cache::CreateCacheBackend(
       cache_type,
       net::CACHE_BACKEND_DEFAULT,
       cache_dir,
       cache_size,
       true /* force_initialize */,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
       NULL, /* dummy net log */
       &disk_cache_,
       base::Bind(&PnaclTranslationCache::OnCreateBackendComplete, AsWeakPtr()));
-  init_callback_ = callback;
-  if (rv != net::ERR_IO_PENDING) {
-    OnCreateBackendComplete(rv);
+  if (rv == net::ERR_IO_PENDING) {
+    init_callback_ = callback;
   }
   return rv;
 }
 
 void PnaclTranslationCache::OnCreateBackendComplete(int rv) {
   if (rv < 0) {
     LOG(ERROR) << "Backend init failed:" << net::ErrorToString(rv);
   }
   // Invoke our client's callback function.
   if (!init_callback_.is_null()) {
-    init_callback_.Run(rv);
-    init_callback_.Reset();
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE, base::Bind(init_callback_, rv));
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 // High-level API
 
 void PnaclTranslationCache::StoreNexe(const std::string& key,
-                                      net::DrainableIOBuffer* nexe_data) {
-  StoreNexe(key, nexe_data, CompletionCallback());
-}
-
-void PnaclTranslationCache::StoreNexe(const std::string& key,
                                       net::DrainableIOBuffer* nexe_data,
                                       const CompletionCallback& callback) {
   PnaclTranslationCacheEntry* entry = PnaclTranslationCacheEntry::GetWriteEntry(
       AsWeakPtr(), key, nexe_data, callback);
   open_entries_[entry] = entry;
   entry->Start();
 }
 
 void PnaclTranslationCache::GetNexe(const std::string& key,
                                     const GetNexeCallback& callback) {
@@ skipping 53 matching lines @@
 }
 
 int PnaclTranslationCache::DoomEntriesBetween(
     base::Time initial,
     base::Time end,
     const CompletionCallback& callback) {
   return disk_cache_->DoomEntriesBetween(initial, end, callback);
 }
 
 }  // namespace pnacl