Add extra error logging to PnaclTranslationCache and PnaclHost

chrome/browser/nacl_host/pnacl_translation_cache.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_translation_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 180 matching lines @@
       offset,
       io_buf_.get(),
       len,
       base::Bind(&PnaclTranslationCacheEntry::DispatchNext, this));
   if (rv != net::ERR_IO_PENDING)
     DispatchNext(rv);
 }
 
 void PnaclTranslationCacheEntry::CloseEntry(int rv) {
   DCHECK(entry_);
-  if (rv < 0)
+  if (rv < 0) {
+    LOG(ERROR) << "PnaclTranslationCache: failed to close entry: "
+               << net::ErrorToString(rv);
     entry_->Doom();
+  }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(&CloseDiskCacheEntry, entry_));
   Finish(rv);
 }
 
 void PnaclTranslationCacheEntry::Finish(int rv) {
   if (is_read_) {
     if (!read_callback_.is_null()) {
       read_callback_.Run(rv, io_buf_);
       read_callback_.Reset();
     }
   } else {
     if (!write_callback_.is_null()) {
       write_callback_.Run(rv);
       write_callback_.Reset();
     }
   }
   cache_->OpComplete(this);
 }
 
 void PnaclTranslationCacheEntry::DispatchNext(int rv) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!cache_)
     return;
 
   switch (step_) {
     case UNINITIALIZED:
-      LOG(ERROR) << "Unexpected step in DispatchNext";
+      LOG(ERROR) << "PnaclTranslationCache: DispatchNext called uninitialized";
       break;
 
     case OPEN_ENTRY:
       if (rv == net::OK) {
         step_ = TRANSFER_ENTRY;
         if (is_read_) {
           int bytes_to_transfer = entry_->GetDataSize(1);
           io_buf_ = new net::DrainableIOBuffer(
               new net::IOBuffer(bytes_to_transfer), bytes_to_transfer);
           ReadEntry(0, bytes_to_transfer);
         } else {
           WriteEntry(0, io_buf_->size());
         }
       } else {
+        if (rv != net::ERR_FAILED) {
+          // ERROR_FAILED is what we expect if the entry doesn't exist.
+          LOG(ERROR) << "PnaclTranslationCache: OpenEntry failed: "
+                     << net::ErrorToString(rv);
+        }
         if (is_read_) {
           // Just a cache miss, not necessarily an error.
           entry_ = NULL;
           Finish(rv);
         } else {
           step_ = CREATE_ENTRY;
           CreateEntry();
         }
       }
       break;
 
     case CREATE_ENTRY:
       if (rv == net::OK) {
         step_ = TRANSFER_ENTRY;
         WriteEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining());
       } else {
-        LOG(ERROR) << "Failed to Create a PNaCl Translation Cache Entry";
+        LOG(ERROR) << "PnaclTranslationCache: Failed to Create Entry: "
+                   << net::ErrorToString(rv);
         Finish(rv);
       }
       break;
 
     case TRANSFER_ENTRY:
       if (rv < 0) {
         // We do not call DispatchNext directly if WriteEntry/ReadEntry returns
         // ERR_IO_PENDING, and the callback should not return that value either.
         LOG(ERROR)
-            << "Failed to complete write to PNaCl Translation Cache Entry: "
-            << rv;
+            << "PnaclTranslationCache: Failed to complete write to entry: "
+            << net::ErrorToString(rv);
         step_ = CLOSE_ENTRY;
         CloseEntry(rv);
         break;
       } else if (rv > 0) {
         io_buf_->DidConsume(rv);
         if (io_buf_->BytesRemaining() > 0) {
           is_read_
               ? ReadEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining())
               : WriteEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining());
           break;
@@ skipping 52 matching lines @@
       &disk_cache_,
       base::Bind(&PnaclTranslationCache::OnCreateBackendComplete, AsWeakPtr()));
   init_callback_ = callback;
   if (rv != net::ERR_IO_PENDING) {
     OnCreateBackendComplete(rv);
   }
   return rv;
 }
 
 void PnaclTranslationCache::OnCreateBackendComplete(int rv) {
+  if (rv < 0) {
+    LOG(ERROR) << "PnaclTranslationCache: backend init failed:"
+               << net::ErrorToString(rv);
+  }
   // Invoke our client's callback function.
   if (!init_callback_.is_null()) {
     init_callback_.Run(rv);
     init_callback_.Reset();
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 // High-level API
 
@@ skipping 72 matching lines @@
 }
 
 int PnaclTranslationCache::DoomEntriesBetween(
     base::Time initial,
     base::Time end,
     const CompletionCallback& callback) {
   return disk_cache_->DoomEntriesBetween(initial, end, callback);
 }
 
 }  // namespace pnacl