Use HTTP response headers for PNaCl caching instead of bitcode hash.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.cc

 // Copyright (c) 2012 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 "native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/plugin/local_temp_file.h"
 #include "native_client/src/trusted/plugin/manifest.h"
+#include "native_client/src/trusted/plugin/nacl_http_response_headers.h"
 #include "native_client/src/trusted/plugin/plugin.h"
 #include "native_client/src/trusted/plugin/plugin_error.h"
 #include "native_client/src/trusted/plugin/pnacl_translate_thread.h"
 #include "native_client/src/trusted/plugin/service_runtime.h"
 #include "native_client/src/trusted/plugin/temporary_file.h"
 #include "native_client/src/trusted/service_runtime/include/sys/stat.h"
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_file_io.h"
@@ skipping 659 matching lines @@
             "(in progress).");
         return;
       }
       ReportPpapiError(
           ERROR_PNACL_CACHE_OPEN_OTHER,
           pp_error,
           "File system for PNaCl translation cache failed to open.");
     }
   } else {
     // We don't have a cache, so do the non-cached codepath.
-    CachedFileDidOpen(PP_ERROR_FAILED);
+    OpenBitcodeStream();
   }
 }
 
 void PnaclCoordinator::FileSystemDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::FileSystemDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(
           ERROR_PNACL_CACHE_OPEN_NOACCESS,
@@ skipping 41 matching lines @@
           "PNaCl translation cache directory creation/check failed "
           "(no access).");
       return;
     }
     ReportPpapiError(
         ERROR_PNACL_CACHE_DIRECTORY_CREATE,
         pp_error,
         "PNaCl translation cache directory creation/check failed.");
     return;
   }
-  if (pnacl_options_.HasCacheKey()) {
+  OpenBitcodeStream();
+}
+
+void PnaclCoordinator::OpenBitcodeStream() {
+  // Now open the pexe stream.
+  streaming_downloader_.reset(new FileDownloader());
+  streaming_downloader_->Initialize(plugin_);
+
+  // Even though we haven't started downloading, create the translation
+  // thread object immediately. This ensures that any pieces of the file
+  // that get downloaded before the compilation thread is accepting
+  // SRPCs won't get dropped.
+  translate_thread_.reset(new PnaclTranslateThread());
+  if (translate_thread_ == NULL) {
+    ReportNonPpapiError(ERROR_PNACL_THREAD_CREATE,
+                        "could not allocate translation thread.");
+    return;
+  }
+  // We also want to open the object file now so the
+  // translator can start writing to it during streaming translation.
+  obj_file_.reset(new TempFile(plugin_));
+  pp::CompletionCallback obj_cb =
+    callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
+  obj_file_->Open(obj_cb);
+
+  pp::CompletionCallback cb =
+      callback_factory_.NewCallback(&PnaclCoordinator::BitcodeStreamDidOpen);
+  if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
+    ReportNonPpapiError(ERROR_PNACL_PEXE_FETCH_OTHER,
+                        nacl::string("failed to open stream ") + pexe_url_);
+  }
+}
+
+void PnaclCoordinator::BitcodeStreamDidOpen(int32_t pp_error) {
+  if (pp_error != PP_OK) {
+    BitcodeStreamDidFinish(pp_error);
+    return;
+  }
+
+  if (!off_the_record_) {
+    // Get the cache key and try to open an existing entry.
+    nacl::string headers = streaming_downloader_->GetResponseHeaders();
+    NaClHttpResponseHeaders parser;
+    parser.Parse(headers);
+    nacl::string cache_validators = parser.GetCacheValidators();
+    if (parser.CacheControlNoStore() || cache_validators.empty()) {
+      // We can't cache in this case.
+      pnacl_options_.set_cache_validators("");
+      CachedFileDidOpen(PP_ERROR_FAILED);
+      return;
+    } else {
+      nacl::string url = streaming_downloader_->url();
+      // For now, combine the cache_validators + the URL as the key.
+      // When we change the cache backend to be not-origin-specific
+      // we should send the URL separately, and check in the browser's
+      // RenderViewHost / SiteInstance's IsSameWebsite() to prevent
+      // people from forging the URL for a different origin.
+      pnacl_options_.set_cache_validators(cache_validators + url);
+    }
     cached_nexe_file_.reset(new LocalTempFile(
         plugin_, file_system_.get(),
         nacl::string(kPnaclTempDir),
         pnacl_options_.GetCacheKey()));
     pp::CompletionCallback cb =
         callback_factory_.NewCallback(&PnaclCoordinator::CachedFileDidOpen);
     cached_nexe_file_->OpenRead(cb);
   } else {
-    // For now, tolerate lack of cache identity...
+    // No cache case.
     CachedFileDidOpen(PP_ERROR_FAILED);
   }
 }
 
 void PnaclCoordinator::CachedFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::CachedFileDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error == PP_OK) {
+    // Cache hit -- no need to stream the rest of the file.
+    streaming_downloader_.reset(NULL);
     HistogramEnumerateTranslationCache(true);
     NexeReadDidOpen(PP_OK);
     return;
   }
-  // Otherwise, the cache file is missing, or the cache simply
-  // cannot be created (e.g., incognito mode), so we must translate.
+  // Otherwise, the cache file is missing so we must translate.
   HistogramEnumerateTranslationCache(false);
 
-  // Create the translation thread object immediately. This ensures that any
-  // pieces of the file that get downloaded before the compilation thread
-  // is accepting SRPCs won't get dropped.
-  translate_thread_.reset(new PnaclTranslateThread());
-  if (translate_thread_ == NULL) {
-    ReportNonPpapiError(ERROR_PNACL_THREAD_CREATE,
-                        "could not allocate translation thread.");
-    return;
-  }
-  // We also want to open the object file now so the
-  // translator can start writing to it during streaming translation.
-  obj_file_.reset(new TempFile(plugin_));
-  pp::CompletionCallback obj_cb =
-    callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
-  obj_file_->Open(obj_cb);
-
-  streaming_downloader_.reset(new FileDownloader());
-  streaming_downloader_->Initialize(plugin_);
+  // Continue streaming.
   pp::CompletionCallback cb =
-      callback_factory_.NewCallback(
-          &PnaclCoordinator::BitcodeStreamDidFinish);
-
-  if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
-    ReportNonPpapiError(ERROR_PNACL_PEXE_FETCH_OTHER,
-                        nacl::string("failed to open stream ") + pexe_url_);
-  }
+      callback_factory_.NewCallback(&PnaclCoordinator::BitcodeStreamDidFinish);
+  streaming_downloader_->FinishStreaming(cb);
 }
 
 void PnaclCoordinator::BitcodeStreamDidFinish(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamDidFinish (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     // Defer reporting the error and cleanup until after the translation
     // thread returns, because it may be accessing the coordinator's
     // objects or writing to the files.
     translate_finish_error_ = pp_error;
@@ skipping 15 matching lines @@
     HistogramRatio("NaCl.Perf.PNaClLoadTime.PctCompiledWhenFullyDownloaded",
                    pexe_bytes_compiled_, pexe_size_);
   }
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(int32_t pp_error,
                                             FileStreamData data) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamGotData (pp_error=%"
                  NACL_PRId32", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
   DCHECK(translate_thread_.get());
+
   translate_thread_->PutBytes(data, pp_error);
   // If pp_error > 0, then it represents the number of bytes received.
   if (data && pp_error > 0) {
     pexe_size_ += pp_error;
   }
 }
 
 StreamCallback PnaclCoordinator::GetCallback() {
   return callback_factory_.NewCallbackWithOutput(
       &PnaclCoordinator::BitcodeStreamGotData);
@@ skipping 71 matching lines @@
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin