Add extra error logging to PnaclTranslationCache and PnaclHost

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 54 matching lines @@
   // Append the base file name to the cache directory.
   return cache_file_path.Append(kTranslationCacheDirectoryName);
 }
 
 void PnaclHost::OnCacheInitialized(int net_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If the cache was cleared before the load completed, ignore.
   if (cache_state_ == CacheReady)
     return;
   if (net_error != net::OK) {
-    LOG(ERROR) << "PNaCl translation cache initalization failure: " << net_error
-               << "\n";
+    // This will cause the cache to attempt to re-init on the next call to
+    // GetNexeFd.
+    cache_state_ = CacheUninitialized;
   } else {
     cache_state_ = CacheReady;
   }
 }
 
 void PnaclHost::Init() {
   // Extra check that we're on the real IO thread since this version of
   // Init isn't used in unit tests.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 26 matching lines @@
 // Create a temporary file on the blocking pool
 // static
 base::PlatformFile PnaclHost::DoCreateTemporaryFile(base::FilePath temp_dir) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   base::FilePath file_path;
   bool rv = temp_dir.empty()
                 ? file_util::CreateTemporaryFile(&file_path)
                 : file_util::CreateTemporaryFileInDir(temp_dir, &file_path);
 
-  if (!rv)
+  if (!rv) {
+    LOG(ERROR) << "PnaclHost:: Temp file creation failed.";
     return base::kInvalidPlatformFileValue;
+  }
   base::PlatformFileError error;
   base::PlatformFile file_handle(base::CreatePlatformFile(
       file_path,
       base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_READ |
           base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_TEMPORARY |
           base::PLATFORM_FILE_DELETE_ON_CLOSE,
       NULL,
       &error));
 
-  if (error != base::PLATFORM_FILE_OK)
+  if (error != base::PLATFORM_FILE_OK) {
+    LOG(ERROR) << "PnaclHost: Temp file open failed: " << error;
     return base::kInvalidPlatformFileValue;
+  }
 
   return file_handle;
 }
 
 void PnaclHost::CreateTemporaryFile(TempFileCallback cb) {
   if (!base::PostTaskAndReplyWithResult(
           BrowserThread::GetBlockingPool(),
           FROM_HERE,
           base::Bind(&PnaclHost::DoCreateTemporaryFile, temp_dir_),
           cb)) {
     DCHECK(thread_checker_.CalledOnValidThread());
     cb.Run(base::kInvalidPlatformFileValue);
   }
 }
 
 ///////////////////////////////////////// GetNexeFd implementation
 ////////////////////// Common steps
 
 void PnaclHost::GetNexeFd(int render_process_id,
                           int render_view_id,
                           int pp_instance,
                           bool is_incognito,
                           const nacl::PnaclCacheInfo& cache_info,
                           const NexeFdCallback& cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (cache_state_ == CacheUninitialized) {
     Init();
   }
-  if (cache_state_ == CacheInitializing) {
+  if (cache_state_ != CacheReady) {
     // If the backend hasn't yet initialized, try the request again later.
     BrowserThread::PostDelayedTask(BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(&PnaclHost::GetNexeFd,
                                               weak_factory_.GetWeakPtr(),
                                               render_process_id,
                                               render_view_id,
                                               pp_instance,
                                               is_incognito,
                                               cache_info,
@@ skipping 48 matching lines @@
 // by PnaclTranslationCache and now belongs to PnaclHost.
 // (Bound callbacks must re-lookup the TranslationID because the translation
 // could be cancelled before they get called).
 void PnaclHost::OnCacheQueryReturn(
     const TranslationID& id,
     int net_error,
     scoped_refptr<net::DrainableIOBuffer> buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PendingTranslationMap::iterator entry(pending_translations_.find(id));
   if (entry == pending_translations_.end()) {
+    LOG(ERROR) << "PnaclHost::OnCacheQueryReturn: id not found";
     return;
   }
   PendingTranslation* pt = &entry->second;
   pt->got_cache_reply = true;
   pt->got_cache_hit = (net_error == net::OK);
   if (pt->got_cache_hit)
     pt->nexe_read_buffer = buffer;
   CheckCacheQueryReady(entry);
 }
 
 // Callback from temp file creation. |id| is bound from
 // SendCacheQueryAndTempFileRequest, and fd is the created file descriptor.
 // If there was an error, fd is kInvalidPlatformFileValue.
 // (Bound callbacks must re-lookup the TranslationID because the translation
 // could be cancelled before they get called).
 void PnaclHost::OnTempFileReturn(const TranslationID& id,
                                  base::PlatformFile fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PendingTranslationMap::iterator entry(pending_translations_.find(id));
   if (entry == pending_translations_.end()) {
     // The renderer may have signaled an error or closed while the temp
     // file was being created.
+    LOG(ERROR) << "PnaclHost::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) << "PnaclHost::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 blocked waiting for an incongnito translation
+    // No translations will be waiting for an incongnito translation
     if (!is_incognito)
       RequeryMatchingTranslations(key);
     return;
   }
   PendingTranslation* pt = &entry->second;
   pt->got_nexe_fd = true;
   pt->nexe_fd = fd;
   CheckCacheQueryReady(entry);
 }
 
@@ skipping 53 matching lines @@
 
 // On error, just return a null refptr.
 // static
 scoped_refptr<net::DrainableIOBuffer> PnaclHost::CopyFileToBuffer(
     base::PlatformFile fd) {
   base::PlatformFileInfo info;
   scoped_refptr<net::DrainableIOBuffer> buffer;
   bool error = false;
   if (!base::GetPlatformFileInfo(fd, &info) ||
       info.size >= std::numeric_limits<int>::max()) {
+    LOG(ERROR) << "PnaclHost: GetPlatformFileInfo failed";
     error = true;
   } else {
     buffer = new net::DrainableIOBuffer(
         new net::IOBuffer(static_cast<int>(info.size)), info.size);
     if (base::ReadPlatformFile(fd, 0, buffer->data(), buffer->size()) !=
-        info.size)
+        info.size) {
+      LOG(ERROR) << "PnaclHost: CopyFileToBuffer write failed";
       error = true;
+    }
   }
   if (error) {
     buffer = NULL;
   }
   base::ClosePlatformFile(fd);
   return buffer;
 }
 
 // Called by the renderer in the miss path to report a finished translation
 void PnaclHost::TranslationFinished(int render_process_id,
@@ skipping 198 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);
 }