Refine PNaCl pexe fetch UMA errors to know if the user aborted, etc.

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"
@@ skipping 331 matching lines @@
     // For now, tolerate bitcode that is missing a cache identity, and
     // tolerate the lack of caching in incognito mode.
     PLUGIN_PRINTF(("PnaclCoordinator -- not caching.\n"));
     NexeReadDidOpen(PP_OK);
   }
 }
 
 void PnaclCoordinator::CachedNexeOpenedForWrite(int32_t pp_error) {
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_NOACCESS) {
-      ReportPpapiError(ERROR_PNACL_CACHE_FILEOPEN_NOACCESS,
-                       pp_error,
-                       "PNaCl translation cache failed to open file for write."
-                       "  No access.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_FILEOPEN_NOACCESS,
+          pp_error,
+          "PNaCl translation cache failed to open file for write "
+          "(no access).");
       return;
     }
     if (pp_error == PP_ERROR_NOQUOTA) {
-      ReportPpapiError(ERROR_PNACL_CACHE_FILEOPEN_NOQUOTA,
-                       pp_error,
-                       "PNaCl translation cache failed to open file for write."
-                       "  No quota.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_FILEOPEN_NOQUOTA,
+          pp_error,
+          "PNaCl translation cache failed to open file for write "
+          "(no quota).");
       return;
     }
     if (pp_error == PP_ERROR_NOSPACE) {
-      ReportPpapiError(ERROR_PNACL_CACHE_FILEOPEN_NOSPACE,
-                       pp_error,
-                       "PNaCl translation cache failed to open file for write."
-                       "  No space.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_FILEOPEN_NOSPACE,
+          pp_error,
+          "PNaCl translation cache failed to open file for write "
+          "(no space).");
       return;
     }
     if (pp_error == PP_ERROR_NOTAFILE) {
       ReportPpapiError(ERROR_PNACL_CACHE_FILEOPEN_NOTAFILE,
                        pp_error,
                        "PNaCl translation cache failed to open file for write."
                        "  File already exists as a directory.");
       return;
     }
     ReportPpapiError(ERROR_PNACL_CACHE_FILEOPEN_OTHER,
@@ skipping 87 matching lines @@
   cached_nexe_file_->write_file_io()->Write(next_offset, buf, num_read, cb);
 }
 
 void PnaclCoordinator::NexeWasCopiedToCache(int32_t pp_error) {
   if (pp_error != PP_OK) {
     // TODO(jvoung): This should try to delete the partially written
     // cache file before returning...
     if (pp_error == PP_ERROR_NOQUOTA) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_NOQUOTA,
                        pp_error,
-                       "Failed to copy translated nexe to cache.  No quota.");
+                       "Failed to copy translated nexe to cache (no quota).");
       return;
     }
     if (pp_error == PP_ERROR_NOSPACE) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_NOSPACE,
                        pp_error,
-                       "Failed to copy translated nexe to cache.  No space.");
+                       "Failed to copy translated nexe to cache (no space).");
       return;
     }
     ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_COPY_OTHER,
                      pp_error,
                      "Failed to copy translated nexe to cache.");
     return;
   }
   // Rename the cached_nexe_file_ file to the cache id, to finalize.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasRenamed);
   cached_nexe_file_->Rename(cache_identity_, cb);
 }
 
 void PnaclCoordinator::NexeFileWasRenamed(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFileWasRenamed (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_RENAME_NOACCESS,
                        pp_error,
-                       "Failed to finalize cached translation.  No access.");
+                       "Failed to finalize cached translation (no access).");
       return;
     } else if (pp_error != PP_ERROR_FILEEXISTS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FINALIZE_RENAME_OTHER,
                        pp_error,
                        "Failed to finalize cached translation.");
       return;
     } else { // pp_error == PP_ERROR_FILEEXISTS.
       // NOTE: if the file already existed, it looks like the rename will
       // happily succeed.  However, we should add a test for this.
       // Could be a hash collision, or it could also be two tabs racing to
@@ skipping 18 matching lines @@
   cached_nexe_file_->OpenRead(cb);
 }
 
 void PnaclCoordinator::NexeReadDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeReadDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     if (pp_error == PP_ERROR_FILENOTFOUND) {
       ReportPpapiError(ERROR_PNACL_CACHE_FETCH_NOTFOUND,
                        pp_error,
-                       "Failed to open translated nexe.  Not found.");
+                       "Failed to open translated nexe (not found).");
       return;
     }
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(ERROR_PNACL_CACHE_FETCH_NOACCESS,
                        pp_error,
-                       "Failed to open translated nexe.  No access.");
+                       "Failed to open translated nexe (no access).");
       return;
     }
     ReportPpapiError(ERROR_PNACL_CACHE_FETCH_OTHER,
                      pp_error,
                      "Failed to open translated nexe.");
     return;
   }
 
   // Transfer ownership of cache/temp file's wrapper to the coordinator.
   if (cached_nexe_file_ != NULL) {
@@ skipping 21 matching lines @@
     int32_t open_error = file_system_->Open(0, cb);
     if (open_error != PP_OK_COMPLETIONPENDING) {
       // At this point, no async request has kicked off to check for
       // permissions, space, etc., so the only error that can be detected
       // now is that an open() is already in progress (or a really terrible
       // error).
       if (pp_error == PP_ERROR_INPROGRESS) {
         ReportPpapiError(
             ERROR_PNACL_CACHE_OPEN_INPROGRESS,
             pp_error,
-            "File system for PNaCl translation cache failed to open."
-            "  In progress.");
+            "File system for PNaCl translation cache failed to open "
+            "(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);
   }
 }
 
 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,
-                       pp_error,
-                       "File system for PNaCl translation cache failed to open."
-                       "  No access.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_OPEN_NOACCESS,
+          pp_error,
+          "File system for PNaCl translation cache failed to open "
+          "(no access).");
       return;
     }
     if (pp_error == PP_ERROR_NOQUOTA) {
-      ReportPpapiError(ERROR_PNACL_CACHE_OPEN_NOQUOTA,
-                       pp_error,
-                       "File system for PNaCl translation cache failed to open."
-                       "  No quota.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_OPEN_NOQUOTA,
+          pp_error,
+          "File system for PNaCl translation cache failed to open "
+          "(no quota).");
       return;
     }
     if (pp_error == PP_ERROR_NOSPACE) {
-      ReportPpapiError(ERROR_PNACL_CACHE_OPEN_NOSPACE,
-                       pp_error,
-                       "File system for PNaCl translation cache failed to open."
-                       "  No space.");
+      ReportPpapiError(
+          ERROR_PNACL_CACHE_OPEN_NOSPACE,
+          pp_error,
+          "File system for PNaCl translation cache failed to open "
+          "(no space).");
       return;
     }
     ReportPpapiError(ERROR_PNACL_CACHE_OPEN_OTHER,
                      pp_error,
                      "File system for PNaCl translation cache failed to open.");
   }
   dir_ref_.reset(new pp::FileRef(*file_system_, kPnaclTempDir));
   // Attempt to create the directory.
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::DirectoryWasCreated);
   dir_ref_->MakeDirectory(cb);
 }
 
 void PnaclCoordinator::DirectoryWasCreated(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::DirectoryWasCreated (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_ERROR_FILEEXISTS && pp_error != PP_OK) {
     // Directory did not exist and could not be created.
     if (pp_error == PP_ERROR_NOACCESS) {
       ReportPpapiError(
           ERROR_PNACL_CACHE_DIRECTORY_CREATE,
           pp_error,
-          "PNaCl translation cache directory creation/check failed.  "
-          "No access.");
+          "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 (cache_identity_ != "") {
     cached_nexe_file_.reset(new LocalTempFile(plugin_, file_system_.get(),
@@ skipping 33 matching lines @@
   pp::CompletionCallback obj_cb =
     callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileDidOpen);
   obj_file_->Open(obj_cb);
 
   streaming_downloader_.reset(new FileDownloader());
   streaming_downloader_->Initialize(plugin_);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &PnaclCoordinator::BitcodeStreamDidFinish);
 
-  // TODO(dschuff): need to use url_util_->ResolveRelativeToURL?
   if (!streaming_downloader_->OpenStream(pexe_url_, cb, this)) {
-    ReportNonPpapiError(ERROR_PNACL_PEXE_FETCH,
+    ReportNonPpapiError(ERROR_PNACL_PEXE_FETCH_OTHER,
                         nacl::string("failed to open stream ") + pexe_url_);
   }
 }
 
 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.
-    // TODO(dschuff,jvoung): If this is a PP_ERROR_ABORTED, we probably
-    // want the UMA stat to show that the user aborted the action
-    // (vs a network error).
-    // We also want to track the total number of bytes of the pexe
-    // to know the typical application sizes.
     translate_finish_error_ = pp_error;
-    nacl::stringstream ss;
-    ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
-    error_info_.SetReport(ERROR_PNACL_PEXE_FETCH, ss.str());
+    if (pp_error == PP_ERROR_ABORTED) {
+      error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_ABORTED,
+                            "PnaclCoordinator: pexe load failed (aborted).");
+    }
+    if (pp_error == PP_ERROR_NOACCESS) {
+      error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_NOACCESS,
+                            "PnaclCoordinator: pexe load failed (no access).");
+    } else {
+      nacl::stringstream ss;
+      ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
+      error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_OTHER, ss.str());
+    }
     translate_thread_->AbortSubprocesses();
   }
 }
 
 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);
@@ skipping 34 matching lines @@
                                   manifest_.get(),
                                   ld_manifest_.get(),
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   plugin_);
 }
 
 }  // namespace plugin