Pepper: Miscellaneous trusted plugin cleanup.

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 26 matching lines @@
 #include "ppapi/native_client/src/trusted/plugin/nacl_entry_points.h"
 #include "ppapi/native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
 #include "ppapi/native_client/src/trusted/plugin/service_runtime.h"
 #include "ppapi/native_client/src/trusted/plugin/utility.h"
 
 namespace plugin {
 
 namespace {
 
-// The pseudo-architecture used to indicate portable native client.
-const char* const kPortableArch = "portable";
 // This is a pretty arbitrary limit on the byte size of the NaCl manfest file.
 // Note that the resulting string object has to have at least one byte extra
 // for the null termination character.
 const size_t kNaClManifestMaxFileBytes = 1024 * 1024;
 
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
@@ skipping 28 matching lines @@
 
 void Plugin::HistogramSizeKB(const std::string& name,
                              int32_t sample) {
   if (sample < 0) return;
   uma_interface_.HistogramCustomCounts(name,
                                        sample,
                                        kSizeKBMin, kSizeKBMax,
                                        kSizeKBBuckets);
 }
 
-void Plugin::HistogramEnumerate(const std::string& name,
-                                int sample,
-                                int maximum,
-                                int out_of_range_replacement) {
-  if (sample < 0 || sample >= maximum) {
-    if (out_of_range_replacement < 0)
-      // No replacement for bad input, abort.
-      return;
-    else
-      // Use a specific value to signal a bad input.
-      sample = out_of_range_replacement;
-  }
-  uma_interface_.HistogramEnumeration(name, sample, maximum);
-}
+void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code) {
+  if (error_code < 0 || error_code > NACL_ERROR_CODE_MAX)
+    error_code = LOAD_STATUS_UNKNOWN;
 
-void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code) {
-  HistogramEnumerate("NaCl.LoadStatus.SelLdr", error_code,
-                     NACL_ERROR_CODE_MAX, LOAD_STATUS_UNKNOWN);
+  uma_interface_.HistogramEnumeration("NaCl.LoadStatus.SelLdr",
+                                      error_code,
+                                      NACL_ERROR_CODE_MAX);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = nacl_interface_->GetIsInstalled(pp_instance()) ?
       "NaCl.LoadStatus.SelLdr.InstalledApp" :
       "NaCl.LoadStatus.SelLdr.NotInstalledApp";
-  HistogramEnumerate(name, error_code, NACL_ERROR_CODE_MAX,
-                     LOAD_STATUS_UNKNOWN);
-}
-
-void Plugin::HistogramHTTPStatusCode(const std::string& name, int status) {
-  // Log the status codes in rough buckets - 1XX, 2XX, etc.
-  int sample = status / 100;
-  // HTTP status codes only go up to 5XX, using "6" to indicate an internal
-  // error.
-  // Note: installed files may have "0" for a status code.
-  if (status < 0 || status >= 600)
-    sample = 6;
-  HistogramEnumerate(name, sample, 7, 6);
+  uma_interface_.HistogramEnumeration(name, error_code, NACL_ERROR_CODE_MAX);
 }
 
 bool Plugin::LoadNaClModuleFromBackgroundThread(
     nacl::DescWrapper* wrapper,
     NaClSubprocess* subprocess,
     int32_t manifest_id,
     const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this, manifest_id, false, uses_nonsfi_mode_,
@@ skipping 372 matching lines @@
 }
 
 void Plugin::NexeDidCrash(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     PLUGIN_PRINTF(("Plugin::NexeDidCrash: CallOnMainThread callback with"
                    " non-PP_OK arg -- SHOULD NOT HAPPEN\n"));
   }
 
-  std::string crash_log = main_service_runtime()->GetCrashLogOutput();
+  std::string crash_log =
+      main_subprocess_.service_runtime()->GetCrashLogOutput();
   nacl_interface_->NexeDidCrash(pp_instance(), crash_log.c_str());
 }
 
 void Plugin::BitcodeDidTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
     // Error should have been reported by pnacl. Just return.
     PLUGIN_PRINTF(("Plugin::BitcodeDidTranslate error in Pnacl\n"));
     return;
@@ skipping 119 matching lines @@
         open_callback.pp_completion_callback());
   }
 }
 
 
 bool Plugin::SetManifestObject(const nacl::string& manifest_json) {
   PLUGIN_PRINTF(("Plugin::SetManifestObject(): manifest_json='%s'.\n",
        manifest_json.c_str()));
   // Determine whether lookups should use portable (i.e., pnacl versions)
   // rather than platform-specific files.
-  bool is_pnacl = nacl_interface_->IsPNaCl(pp_instance());
   pp::Var manifest_base_url =
       pp::Var(pp::PASS_REF, nacl_interface_->GetManifestBaseURL(pp_instance()));
   std::string manifest_base_url_str = manifest_base_url.AsString();
-  const char* sandbox_isa = nacl_interface_->GetSandboxArch();
 
   int32_t manifest_id = nacl_interface_->CreateJsonManifest(
       pp_instance(),
       manifest_base_url_str.c_str(),
-      is_pnacl ? kPortableArch : sandbox_isa,
       manifest_json.c_str());
   if (manifest_id == -1)
     return false;
   manifest_id_ = manifest_id;
   return true;
 }
 
 void Plugin::UrlDidOpenForStreamAsFile(
     int32_t pp_error,
     FileDownloader* url_downloader,
@@ skipping 202 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin