Revert 221275 "Handle cache-control:no-store header in PNaCl tra..."

> Handle cache-control:no-store header in PNaCl translation cache
> 
> Pexe files with the cache-control:no-store header should not be cached.
> Add a field to the PnaclCacheInfo struct, plumb the value all the way
> from the plugin to the browser, and treat it basically the same way we
> currently treat incognito translations (since we currently don't have an
> off-the-record cache for those).
> R=jvoung@chromium.org
> BUG=none, noticed this was missing when doing cleanup
> 
> Review URL: https://chromiumcodereview.appspot.com/23458015

TBR=dschuff@chromium.org

Review URL: https://codereview.chromium.org/23684032

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221281 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 29 insertions, 74 deletions

diff --git a/chrome/browser/nacl_host/pnacl_host.cc b/chrome/browser/nacl_host/pnacl_host.cc
index 59f579f9..2c3a082 100644
--- a/chrome/browser/nacl_host/pnacl_host.cc
+++ b/chrome/browser/nacl_host/pnacl_host.cc
@@ -45,12 +45,6 @@ PnaclHost::PendingTranslation::PendingTranslation()
       cache_info(nacl::PnaclCacheInfo()) {}
 PnaclHost::PendingTranslation::~PendingTranslation() {}
 
-bool PnaclHost::TranslationMayBeCached(
-    const PendingTranslationMap::iterator& entry) {
-  return !entry->second.is_incognito &&
-         !entry->second.cache_info.has_no_store_header;
-}
-
 /////////////////////////////////////// Initialization
 
 static base::FilePath GetCachePath() {
@@ -274,10 +268,11 @@ void PnaclHost::OnTempFileReturn(const TranslationID& id,
     // waiting for its result.
     LOG(ERROR) << "OnTempFileReturn: temp file creation failed";
     std::string key(entry->second.cache_key);
+    bool is_incognito = entry->second.is_incognito;
     entry->second.callback.Run(fd, false);
     pending_translations_.erase(entry);
-    // No translations will be waiting for entries that will not be stored.
-    if (TranslationMayBeCached(entry))
+    // No translations will be waiting for an incongnito translation
+    if (!is_incognito)
       RequeryMatchingTranslations(key);
     return;
   }
@@ -304,9 +299,9 @@ void PnaclHost::CheckCacheQueryReady(
       if (it->second.cache_key == entry->second.cache_key &&
           // and it's not this translation,
           it->first != entry->first &&
-          // and it can be stored in the cache,
-          TranslationMayBeCached(it) &&
-          // and it's already gotten past this check and returned the miss.
+          // and it's not incognito,
+          !it->second.is_incognito &&
+          // and if it's already gotten past this check and returned the miss.
           it->second.got_cache_reply &&
           it->second.got_nexe_fd) {
         return;
@@ -389,7 +384,7 @@ void PnaclHost::TranslationFinished(int render_process_id,
   // TODO(dschuff): use a separate in-memory cache for incognito
   // translations.
   if (!entry->second.got_nexe_fd || !entry->second.got_cache_reply ||
-      !success || !TranslationMayBeCached(entry)) {
+      !success || entry->second.is_incognito) {
     store_nexe = false;
   } else if (!base::PostTaskAndReplyWithResult(
                   BrowserThread::GetBlockingPool(),
@@ -530,9 +525,10 @@ void PnaclHost::RendererClosing(int render_process_id) {
           base::Bind(base::IgnoreResult(base::ClosePlatformFile),
                      to_erase->second.nexe_fd));
       std::string key(to_erase->second.cache_key);
+      bool is_incognito = to_erase->second.is_incognito;
       pending_translations_.erase(to_erase);
-      // No translations will be waiting for entries that will not be stored.
-      if (TranslationMayBeCached(to_erase))
+      // No translations will be blocked waiting for an incongnito translation
+      if (!is_incognito)
         RequeryMatchingTranslations(key);
     }
   }
diff --git a/chrome/browser/nacl_host/pnacl_host.h b/chrome/browser/nacl_host/pnacl_host.h
index 91553f4..b2f6984 100644
--- a/chrome/browser/nacl_host/pnacl_host.h
+++ b/chrome/browser/nacl_host/pnacl_host.h
@@ -125,8 +125,6 @@ class PnaclHost {
 
   typedef std::pair<int, int> TranslationID;
   typedef std::map<TranslationID, PendingTranslation> PendingTranslationMap;
-  static bool TranslationMayBeCached(
-      const PendingTranslationMap::iterator& entry);
 
   void InitForTest(base::FilePath temp_dir);
   void OnCacheInitialized(int net_error);
diff --git a/chrome/browser/nacl_host/pnacl_host_unittest.cc b/chrome/browser/nacl_host/pnacl_host_unittest.cc
index fc26d1a..0ad9cd5 100644
--- a/chrome/browser/nacl_host/pnacl_host_unittest.cc
+++ b/chrome/browser/nacl_host/pnacl_host_unittest.cc
@@ -47,10 +47,12 @@ class PnaclHostTest : public testing::Test {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   }
-  int GetCacheSize() { return host_->disk_cache_->Size(); }
+  int GetCacheSize() {
+    return host_->disk_cache_->Size();
+  }
 
  public:  // Required for derived classes to bind this method
-          // Callbacks used by tests which call GetNexeFd.
+  // 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
@@ -97,22 +99,21 @@ static nacl::PnaclCacheInfo GetTestCacheInfo() {
   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,                                                    \
-        incognito,                                                   \
-        info,                                                        \
-        base::Bind(expect_hit ? &PnaclHostTest::CallbackExpectHit    \
-                              : &PnaclHostTest::CallbackExpectMiss,  \
-                   base::Unretained(this)));                         \
+#define GET_NEXE_FD(renderer, instance, incognito, info, expect_hit)\
+  do {                                                              \
+    SCOPED_TRACE("");                                               \
+    host_->GetNexeFd(                                               \
+        renderer,                                                   \
+        0, /* ignore render_view_id for now */                      \
+        instance,                                                   \
+        incognito,                                                  \
+        info,                                                       \
+        base::Bind(expect_hit ? &PnaclHostTest::CallbackExpectHit   \
+                              : &PnaclHostTest::CallbackExpectMiss, \
+                   base::Unretained(this)));                        \
   } while (0)
 
 TEST_F(PnaclHostTest, BasicMiss) {
@@ -163,6 +164,7 @@ TEST_F(PnaclHostTest, BasicHit) {
 
 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);
@@ -345,45 +347,6 @@ TEST_F(PnaclHostTest, IncognitoSecondOverlappedMiss) {
   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
@@ -399,8 +362,8 @@ TEST_F(PnaclHostTest, ClearTranslationCache) {
   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));
+  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());
diff --git a/chrome/renderer/pepper/ppb_nacl_private_impl.cc b/chrome/renderer/pepper/ppb_nacl_private_impl.cc
index 967ea6d..00a3b2c 100644
--- a/chrome/renderer/pepper/ppb_nacl_private_impl.cc
+++ b/chrome/renderer/pepper/ppb_nacl_private_impl.cc
@@ -258,7 +258,6 @@ int32_t GetNexeFd(PP_Instance instance,
                   uint32_t opt_level,
                   const char* last_modified,
                   const char* etag,
-                  PP_Bool has_no_store_header,
                   PP_Bool* is_hit,
                   PP_FileHandle* handle,
                   struct PP_CompletionCallback callback) {
@@ -281,7 +280,6 @@ int32_t GetNexeFd(PP_Instance instance,
   cache_info.opt_level = opt_level;
   cache_info.last_modified = last_modified_time;
   cache_info.etag = std::string(etag);
-  cache_info.has_no_store_header = PP_ToBool(has_no_store_header);
 
   g_pnacl_resource_host.Get()->RequestNexeFd(
       GetRoutingID(instance),