Delete PNaCl translation cache backend object when no longer needed

chrome/browser/nacl_host/pnacl_host_unittest.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_host.h"
 
 #include <stdio.h>
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
@@ skipping 14 matching lines @@
  protected:
   PnaclHostTest()
       : host_(NULL),
         temp_callback_count_(0),
         write_callback_count_(0),
         thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
   virtual void SetUp() {
     host_ = new PnaclHost();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     host_->InitForTest(temp_dir_.path());
-    EXPECT_EQ(host_->cache_state_, PnaclHost::CacheReady);
+    base::RunLoop().RunUntilIdle();
+    EXPECT_EQ(PnaclHost::CacheReady, host_->cache_state_);
   }
   virtual void TearDown() {
     EXPECT_EQ(0U, host_->pending_translations());
+    // Give the host a chance to de-init the backend, and then delete it.
+    host_->RendererClosing(0);
+    FlushQueues();
+    EXPECT_EQ(PnaclHost::CacheUninitialized, host_->cache_state_);
     delete host_;
   }
   // Flush the blocking pool first, then any tasks it posted to the IO thread.
   // Do 2 rounds of flushing, because some operations require 2 trips back and
   // forth between the threads.
   void FlushQueues() {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
   int GetCacheSize() { return host_->disk_cache_->Size(); }
+  int CacheIsInitialized() {
+    return host_->cache_state_ == PnaclHost::CacheReady;
+  }
+  void ReInitBackend() {
+    host_->InitForTest(temp_dir_.path());
+    base::RunLoop().RunUntilIdle();
+    EXPECT_EQ(PnaclHost::CacheReady, host_->cache_state_);
+  }
 
  public:  // Required for derived classes to bind this method
           // Callbacks used by tests which call GetNexeFd.
   // CallbackExpectMiss checks that the fd is valid and a miss is reported,
   // and also writes some data into the file, which is read back by
   // CallbackExpectHit
   void CallbackExpectMiss(base::PlatformFile fd, bool is_hit) {
     EXPECT_FALSE(is_hit);
     ASSERT_FALSE(fd == base::kInvalidPlatformFileValue);
     base::PlatformFileInfo info;
@@ skipping 65 matching lines @@
   host_->TranslationFinished(0, 0, true);
   FlushQueues();
   EXPECT_EQ(0U, host_->pending_translations());
   // Test that a different cache info field also misses.
   info.etag = std::string("something else");
   GET_NEXE_FD(0, 0, false, info, false);
   FlushQueues();
   EXPECT_EQ(2, temp_callback_count_);
   EXPECT_EQ(1U, host_->pending_translations());
   host_->RendererClosing(0);
+  FlushQueues();
+  // Check that the cache has de-initialized after the last renderer goes away.
+  EXPECT_FALSE(CacheIsInitialized());
 }
 
 TEST_F(PnaclHostTest, BadArguments) {
   nacl::PnaclCacheInfo info = GetTestCacheInfo();
   GET_NEXE_FD(0, 0, false, info, false);
   EXPECT_EQ(1U, host_->pending_translations());
   host_->TranslationFinished(0, 1, true);  // nonexistent translation
   EXPECT_EQ(1U, host_->pending_translations());
   host_->RendererClosing(1);  // nonexistent renderer
   EXPECT_EQ(1U, host_->pending_translations());
@@ skipping 16 matching lines @@
 }
 
 TEST_F(PnaclHostTest, TranslationErrors) {
   nacl::PnaclCacheInfo info = GetTestCacheInfo();
   GET_NEXE_FD(0, 0, false, info, false);
   // Early abort, before temp file request returns
   host_->TranslationFinished(0, 0, false);
   FlushQueues();
   EXPECT_EQ(0U, host_->pending_translations());
   EXPECT_EQ(0, temp_callback_count_);
+  // The backend will have been freed when the query comes back and there
+  // are no pending translations.
+  EXPECT_FALSE(CacheIsInitialized());
+  ReInitBackend();
   // Check that another request for the same info misses successfully.
   GET_NEXE_FD(0, 0, false, info, false);
   FlushQueues();
   host_->TranslationFinished(0, 0, true);
   FlushQueues();
   EXPECT_EQ(1, temp_callback_count_);
   EXPECT_EQ(0U, host_->pending_translations());
 
   // Now try sending the error after the temp file request returns
   info.abi_version = 222;
@@ skipping 212 matching lines @@
   EXPECT_EQ(2, temp_callback_count_);
   host_->TranslationFinished(0, 0, true);
   host_->TranslationFinished(0, 1, true);
   FlushQueues();
   EXPECT_EQ(0U, host_->pending_translations());
   EXPECT_EQ(2, GetCacheSize());
   net::TestCompletionCallback cb;
   // Since we are using a memory backend, the clear should happen immediately.
   host_->ClearTranslationCacheEntriesBetween(
       base::Time(), base::Time(), base::Bind(cb.callback(), 0));
+  // Check that the translation cache has been cleared before flushing the
+  // queues, because the backend will be freed once it is.
+  EXPECT_EQ(0, GetCacheSize());
   EXPECT_EQ(0, cb.GetResult(net::ERR_IO_PENDING));
-  // Check that the translation cache has been cleared
-  EXPECT_EQ(0, GetCacheSize());
-  host_->RendererClosing(0);
+  // Now check that the backend has been freed.
+  EXPECT_FALSE(CacheIsInitialized());
 }
 
 }  // namespace pnacl