Handle cache-control:no-store header in PNaCl translation cache

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 81 matching lines @@
   int write_callback_count_;
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_dir_;
 };
 
 static nacl::PnaclCacheInfo GetTestCacheInfo() {
   nacl::PnaclCacheInfo info;
   info.pexe_url = GURL("http://www.google.com");
   info.abi_version = 0;
   info.opt_level = 0;
+  info.has_no_store_header = false;
   return info;
 }
 
 #define GET_NEXE_FD(renderer, instance, incognito, info, expect_hit)\
   do {                                                              \
     SCOPED_TRACE("");                                               \
     host_->GetNexeFd(                                               \
         renderer,                                                   \
         0, /* ignore render_view_id for now */                      \
         instance,                                                   \
@@ skipping 45 matching lines @@
   host_->TranslationFinished(0, 0, true);
   FlushQueues();
   GET_NEXE_FD(0, 1, false, info, true);
   FlushQueues();
   EXPECT_EQ(2, temp_callback_count_);
   EXPECT_EQ(0U, host_->pending_translations());
 }
 
 TEST_F(PnaclHostTest, TranslationErrors) {
   nacl::PnaclCacheInfo info = GetTestCacheInfo();
-  info.pexe_url = GURL("http://www.google.com");
   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_);
   // Check that another request for the same info misses successfully.
   GET_NEXE_FD(0, 0, false, info, false);
   FlushQueues();
   host_->TranslationFinished(0, 0, true);
@@ skipping 162 matching lines @@
   EXPECT_EQ(2U, host_->pending_translations());
   FlushQueues();
   EXPECT_EQ(2U, host_->pending_translations());
   EXPECT_EQ(1, temp_callback_count_);
   host_->TranslationFinished(0, 0, true);
   FlushQueues();
   EXPECT_EQ(2, temp_callback_count_);
   EXPECT_EQ(0U, host_->pending_translations());
 }
 
+// Test that pexes with the no-store header do not get cached.
+TEST_F(PnaclHostTest, CacheControlNoStore) {
+  nacl::PnaclCacheInfo info = GetTestCacheInfo();
+  info.has_no_store_header = true;
+  GET_NEXE_FD(0, 0, false, info, false);
+  FlushQueues();
+  EXPECT_EQ(1, temp_callback_count_);
+  host_->TranslationFinished(0, 0, true);
+  FlushQueues();
+  EXPECT_EQ(0U, host_->pending_translations());
+  EXPECT_EQ(0, GetCacheSize());
+}
+
+// Test that no-store pexes do not wait, but do duplicate translations
+TEST_F(PnaclHostTest, NoStoreOverlappedMiss) {
+  nacl::PnaclCacheInfo info = GetTestCacheInfo();
+  info.has_no_store_header = true;
+  GET_NEXE_FD(0, 0, false, info, false);
+  GET_NEXE_FD(0, 1, false, info, false);
+  FlushQueues();
+  // Check that both translations have returned misses, (i.e. that the
+  // second one has not blocked on the first one)
+  EXPECT_EQ(2, temp_callback_count_);
+  host_->TranslationFinished(0, 0, true);
+  host_->TranslationFinished(0, 1, true);
+  FlushQueues();
+  EXPECT_EQ(0U, host_->pending_translations());
+
+  // Same test, but issue the 2nd request after the first has returned a miss.
+  info.abi_version = 222;
+  GET_NEXE_FD(0, 0, false, info, false);
+  FlushQueues();
+  EXPECT_EQ(3, temp_callback_count_);
+  GET_NEXE_FD(0, 1, false, info, false);
+  FlushQueues();
+  EXPECT_EQ(4, temp_callback_count_);
+  host_->RendererClosing(0);
+}
+
 TEST_F(PnaclHostTest, ClearTranslationCache) {
   nacl::PnaclCacheInfo info = GetTestCacheInfo();
   // Add 2 entries in the cache
   GET_NEXE_FD(0, 0, false, info, false);
   info.abi_version = 222;
   GET_NEXE_FD(0, 1, false, info, false);
   FlushQueues();
   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));
   EXPECT_EQ(0, cb.GetResult(net::ERR_IO_PENDING));
   // Check that the translation cache has been cleared
   EXPECT_EQ(0, GetCacheSize());
   host_->RendererClosing(0);
 }
 
 }  // namespace pnacl