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 57 matching lines @@
 
 void Plugin::HistogramTimeSmall(const std::string& name,
                                 int64_t ms) {
   if (ms < 0) return;
   uma_interface_.HistogramCustomTimes(name,
                                       ms,
                                       kTimeSmallMin, kTimeSmallMax,
                                       kTimeSmallBuckets);
 }
 
-void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code) {
-  if (error_code < 0 || error_code > NACL_ERROR_CODE_MAX)
-    error_code = 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";
-  uma_interface_.HistogramEnumeration(name, error_code, NACL_ERROR_CODE_MAX);
-}
-
 bool Plugin::LoadNaClModuleFromBackgroundThread(
     PP_FileHandle file_handle,
     NaClSubprocess* subprocess,
     const SelLdrStartParams& params) {
   CHECK(!pp::Module::Get()->core()->IsMainThread());
   ServiceRuntime* service_runtime =
       new ServiceRuntime(this, false, uses_nonsfi_mode_,
                          pp::BlockUntilComplete(), pp::BlockUntilComplete());
   subprocess->set_service_runtime(service_runtime);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleFromBackgroundThread "
@@ skipping 206 matching lines @@
   return nacl_subprocess.release();
 }
 
 // All failures of this function will show up as "Missing Plugin-in", so
 // there is no need to log to JS console that there was an initialization
 // failure. Note that module loading functions will log their own errors.
 bool Plugin::Init(uint32_t argc, const char* argn[], const char* argv[]) {
   PLUGIN_PRINTF(("Plugin::Init (argc=%" NACL_PRIu32 ")\n", argc));
   nacl_interface_->InitializePlugin(pp_instance(), argc, argn, argv);
   wrapper_factory_ = new nacl::DescWrapperFactory();
-  pp::Var manifest_url(pp::PASS_REF, nacl_interface_->GetManifestURLArgument(
-      pp_instance()));
-  if (manifest_url.is_string() && !manifest_url.AsString().empty())
-    RequestNaClManifest(manifest_url.AsString());
+  pp::CompletionCallback open_cb =
+      callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
+  nacl_interface_->RequestNaClManifest(pp_instance(),
+                                       open_cb.pp_completion_callback());
   return true;
 }
 
 Plugin::Plugin(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
       main_subprocess_("main subprocess", NULL, NULL),
       uses_nonsfi_mode_(false),
       wrapper_factory_(NULL),
       time_of_last_progress_event_(0),
       nacl_interface_(NULL),
@@ skipping 80 matching lines @@
       nexe_file_info_,
       uses_nonsfi_mode_,
       true, /* enable_dyncode_syscalls */
       true, /* enable_exception_handling */
       false, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::NexeFileDidOpenContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::NexeFileDidOpenContinuation(int32_t pp_error) {
-  bool was_successful;
-
   UNREFERENCED_PARAMETER(pp_error);
   NaClLog(4, "Entered NexeFileDidOpenContinuation\n");
-  NaClLog(4, "NexeFileDidOpenContinuation: invoking"
-          " LoadNaClModuleContinuationIntern\n");
-  was_successful = LoadNaClModuleContinuationIntern();
-  if (was_successful) {
+  if (LoadNaClModuleContinuationIntern()) {
     NaClLog(4, "NexeFileDidOpenContinuation: success;"
             " setting histograms\n");
     int64_t nexe_size = nacl_interface_->GetNexeSize(pp_instance());
-    ReportLoadSuccess(nexe_size, nexe_size);
+    nacl_interface_->ReportLoadSuccess(
+        pp_instance(), program_url_.c_str(), nexe_size, nexe_size);
   } else {
     NaClLog(4, "NexeFileDidOpenContinuation: failed.");
   }
   NaClLog(4, "Leaving NexeFileDidOpenContinuation\n");
 }
 
 void Plugin::NexeDidCrash(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NexeDidCrash (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   if (pp_error != PP_OK) {
@@ skipping 26 matching lines @@
       info,
       false, /* uses_nonsfi_mode */
       false, /* enable_dyncode_syscalls */
       false, /* enable_exception_handling */
       true, /* enable_crash_throttling */
       callback_factory_.NewCallback(&Plugin::BitcodeDidTranslateContinuation),
       callback_factory_.NewCallback(&Plugin::NexeDidCrash));
 }
 
 void Plugin::BitcodeDidTranslateContinuation(int32_t pp_error) {
-  bool was_successful = LoadNaClModuleContinuationIntern();
-
   NaClLog(4, "Entered BitcodeDidTranslateContinuation\n");
   UNREFERENCED_PARAMETER(pp_error);
-  if (was_successful) {
+  if (LoadNaClModuleContinuationIntern()) {
     int64_t loaded;
     int64_t total;
+    // TODO(teravest): Tighten this up so we can get rid of
+    // GetCurrentProgress(). loaded should always equal total.
     pnacl_coordinator_->GetCurrentProgress(&loaded, &total);
-    ReportLoadSuccess(loaded, total);
+    nacl_interface_->ReportLoadSuccess(
+        pp_instance(), program_url_.c_str(), loaded, total);
   }
 }
 
 void Plugin::NaClManifestFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("Plugin::NaClManifestFileDidOpen (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK)
     return;
 
   PP_Var pp_program_url;
@@ skipping 21 matching lines @@
       // Will always call the callback on success or failure.
       nacl_interface_->DownloadNexe(pp_instance(),
                                     program_url_.c_str(),
                                     &nexe_file_info_,
                                     open_callback.pp_completion_callback());
       return;
     }
   }
 }
 
-void Plugin::RequestNaClManifest(const nacl::string& url) {
-  PLUGIN_PRINTF(("Plugin::RequestNaClManifest (url='%s')\n", url.c_str()));
-  pp::CompletionCallback open_callback =
-      callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
-  nacl_interface_->RequestNaClManifest(pp_instance(),
-                                       url.c_str(),
-                                       open_callback.pp_completion_callback());
-}
-
-void Plugin::ReportLoadSuccess(uint64_t loaded_bytes, uint64_t total_bytes) {
-  nacl_interface_->ReportLoadSuccess(
-      pp_instance(), program_url_.c_str(), loaded_bytes, total_bytes);
-}
-
-
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   nacl_interface_->ReportLoadError(pp_instance(),
                                    error_info.error_code(),
                                    error_info.message().c_str(),
                                    error_info.console_message().c_str());
 }
 
-
-void Plugin::ReportLoadAbort() {
-  nacl_interface_->ReportLoadAbort(pp_instance());
-}
-
-void Plugin::ReportSelLdrLoadStatus(int status) {
-  HistogramEnumerateSelLdrLoadStatus(static_cast<NaClErrorCode>(status));
-}
-
 bool Plugin::DocumentCanRequest(const std::string& url) {
   CHECK(pp::Module::Get()->core()->IsMainThread());
   CHECK(pp::URLUtil_Dev::Get() != NULL);
   return pp::URLUtil_Dev::Get()->DocumentCanRequest(this, pp::Var(url));
 }
 
 void Plugin::set_exit_status(int exit_status) {
   pp::Core* core = pp::Module::Get()->core();
   if (core->IsMainThread()) {
     SetExitStatusOnMainThread(PP_OK, exit_status);
   } else {
     pp::CompletionCallback callback =
         callback_factory_.NewCallback(&Plugin::SetExitStatusOnMainThread,
                                       exit_status);
     core->CallOnMainThread(0, callback, 0);
   }
 }
 
 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