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

chrome/browser/nacl_host/pnacl_host.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 27 matching lines @@
       render_view_id(0),
       nexe_fd(base::kInvalidPlatformFileValue),
       got_nexe_fd(false),
       got_cache_reply(false),
       got_cache_hit(false),
       is_incognito(false),
       callback(NexeFdCallback()),
       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() {
   NaClBrowserDelegate* browser_delegate = NaClBrowser::GetDelegate();
   // Determine where the translation cache resides in the file system.  It
   // exists in Chrome's cache directory and is not tied to any specific
   // profile. If we fail, return an empty path.
   // Start by finding the user data directory.
   base::FilePath user_data_dir;
   if (!browser_delegate ||
@@ skipping 203 matching lines @@
     LOG(ERROR) << "OnTempFileReturn: id not found";
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(base::IgnoreResult(base::ClosePlatformFile), fd));
     return;
   }
   if (fd == base::kInvalidPlatformFileValue) {
     // This translation will fail, but we need to retry any translation
     // 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 an incongnito translation
-    if (!is_incognito)
+    // No translations will be waiting for entries that will not be stored.
+    if (TranslationMayBeCached(entry))
       RequeryMatchingTranslations(key);
     return;
   }
   PendingTranslation* pt = &entry->second;
   pt->got_nexe_fd = true;
   pt->nexe_fd = fd;
   CheckCacheQueryReady(entry);
 }
 
 // Check whether both the cache query and the temp file have returned, and check
 // whether we actually got a hit or not.
 void PnaclHost::CheckCacheQueryReady(
     const PendingTranslationMap::iterator& entry) {
   PendingTranslation* pt = &entry->second;
   if (!(pt->got_cache_reply && pt->got_nexe_fd))
     return;
   if (!pt->got_cache_hit) {
     // Check if there is already a pending translation for this file. If there
     // is, we will wait for it to come back, to avoid redundant translations.
     for (PendingTranslationMap::iterator it = pending_translations_.begin();
          it != pending_translations_.end();
          ++it) {
       // Another translation matches if it's a request for the same file,
       if (it->second.cache_key == entry->second.cache_key &&
           // and it's not this translation,
           it->first != entry->first &&
-          // and it's not incognito,
-          !it->second.is_incognito &&
-          // and if it's already gotten past this check and returned the miss.
+          // and it can be stored in the cache,
+          TranslationMayBeCached(it) &&
+          // and it's already gotten past this check and returned the miss.
           it->second.got_cache_reply &&
           it->second.got_nexe_fd) {
         return;
       }
     }
     ReturnMiss(entry);
     return;
   }
 
   if (!base::PostTaskAndReplyWithResult(
@@ skipping 62 matching lines @@
                << "," << pp_instance << " not found.";
     return;
   }
   bool store_nexe = true;
   // If this is a premature response (i.e. we haven't returned a temp file
   // yet) or if it's an unsuccessful translation, or if we are incognito,
   // don't store in the cache.
   // TODO(dschuff): use a separate in-memory cache for incognito
   // translations.
   if (!entry->second.got_nexe_fd || !entry->second.got_cache_reply ||
-      !success || entry->second.is_incognito) {
+      !success || !TranslationMayBeCached(entry)) {
     store_nexe = false;
   } else if (!base::PostTaskAndReplyWithResult(
                   BrowserThread::GetBlockingPool(),
                   FROM_HERE,
                   base::Bind(&PnaclHost::CopyFileToBuffer,
                              entry->second.nexe_fd),
                   base::Bind(&PnaclHost::StoreTranslatedNexe,
                              weak_factory_.GetWeakPtr(),
                              id))) {
     store_nexe = false;
@@ skipping 120 matching lines @@
   for (PendingTranslationMap::iterator it = pending_translations_.begin();
        it != pending_translations_.end();) {
     PendingTranslationMap::iterator to_erase(it++);
     if (to_erase->first.first == render_process_id) {
       // Clean up the open files.
       BrowserThread::PostBlockingPoolTask(
           FROM_HERE,
           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;
+      bool may_be_cached = TranslationMayBeCached(to_erase);
       pending_translations_.erase(to_erase);
-      // No translations will be blocked waiting for an incongnito translation
-      if (!is_incognito)
+      // No translations will be waiting for entries that will not be stored.
+      if (may_be_cached)
         RequeryMatchingTranslations(key);
     }
   }
   if (pending_translations_.empty()) {
     cache_state_ = CacheUninitialized;
     // Freeing the backend causes it to flush to disk, so do it when the
     // last renderer closes rather than on destruction.
     disk_cache_.reset();
   }
 }
@@ skipping 26 matching lines @@
       end_time,
       base::Bind(&PnaclHost::OnEntriesDoomed, callback));
   if (rv != net::ERR_IO_PENDING)
     OnEntriesDoomed(callback, rv);
 }
 
 // static
 void PnaclHost::OnEntriesDoomed(const base::Closure& callback, int net_error) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
 }