NaCl cleanup: Remove not-very-useful debug logging in the plugin code

components/nacl/renderer/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 "components/nacl/renderer/plugin/pnacl_coordinator.h"
 
 #include <algorithm>
 #include <sstream>
 #include <utility>
 
@@ skipping 44 matching lines @@
   &DidFinishStream
 };
 
 }  // namespace
 
 PnaclCoordinator* PnaclCoordinator::BitcodeToNative(
     Plugin* plugin,
     const std::string& pexe_url,
     const PP_PNaClOptions& pnacl_options,
     const pp::CompletionCallback& translate_notify_callback) {
-  PLUGIN_PRINTF(("PnaclCoordinator::BitcodeToNative (plugin=%p, pexe=%s)\n",
-                 static_cast<void*>(plugin), pexe_url.c_str()));
   PnaclCoordinator* coordinator =
       new PnaclCoordinator(plugin, pexe_url,
                            pnacl_options,
                            translate_notify_callback);
 
   GetNaClInterface()->SetPNaClStartTime(plugin->pp_instance());
   int cpus = plugin->nacl_interface()->GetNumberOfProcessors();
   coordinator->num_threads_ = std::min(4, std::max(1, cpus));
   if (pnacl_options.use_subzero) {
     coordinator->split_module_count_ = 1;
@@ skipping 23 matching lines @@
       split_module_count_(0),
       num_threads_(0),
       error_already_reported_(false),
       pexe_size_(0),
       pexe_bytes_compiled_(0),
       expected_pexe_size_(-1) {
   callback_factory_.Initialize(this);
 }
 
 PnaclCoordinator::~PnaclCoordinator() {
-  PLUGIN_PRINTF(("PnaclCoordinator::~PnaclCoordinator (this=%p, "
-                 "translate_thread=%p\n",
-                 static_cast<void*>(this), translate_thread_.get()));
   // Stopping the translate thread will cause the translate thread to try to
   // run translation_complete_callback_ on the main thread.  This destructor is
   // running from the main thread, and by the time it exits, callback_factory_
   // will have been destroyed.  This will result in the cancellation of
   // translation_complete_callback_, so no notification will be delivered.
   if (translate_thread_.get() != NULL)
     translate_thread_->AbortSubprocesses();
   if (!translation_finished_reported_) {
     plugin_->nacl_interface()->ReportTranslationFinished(
         plugin_->pp_instance(), PP_FALSE, pnacl_options_.opt_level,
@@ skipping 13 matching lines @@
 
 void PnaclCoordinator::ReportNonPpapiError(PP_NaClError err_code,
                                            const std::string& message) {
   ErrorInfo error_info;
   error_info.SetReport(err_code, message);
   plugin_->ReportLoadError(error_info);
   ExitWithError();
 }
 
 void PnaclCoordinator::ExitWithError() {
-  PLUGIN_PRINTF(("PnaclCoordinator::ExitWithError\n"));
   // Free all the intermediate callbacks we ever created.
   // Note: this doesn't *cancel* the callbacks from the factories attached
   // to the various helper classes (e.g., pnacl_resources). Thus, those
   // callbacks may still run asynchronously.  We let those run but ignore
   // any other errors they may generate so that they do not end up running
   // translate_notify_callback_, which has already been freed.
   callback_factory_.CancelAll();
   if (!error_already_reported_) {
     error_already_reported_ = true;
     translation_finished_reported_ = true;
     plugin_->nacl_interface()->ReportTranslationFinished(
         plugin_->pp_instance(), PP_FALSE, pnacl_options_.opt_level,
         pnacl_options_.use_subzero, 0, 0, 0);
     translate_notify_callback_.Run(PP_ERROR_FAILED);
   }
 }
 
 // Signal that Pnacl translation completed normally.
 void PnaclCoordinator::TranslateFinished(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::TranslateFinished (pp_error=%"
-                 NACL_PRId32 ")\n", pp_error));
   // Bail out if there was an earlier error (e.g., pexe load failure),
   // or if there is an error from the translation thread.
   if (translate_finish_error_ != PP_OK || pp_error != PP_OK) {
     plugin_->ReportLoadError(error_info_);
     ExitWithError();
     return;
   }
 
   // Send out one last progress event, to finish up the progress events
   // that were delayed (see the delay inserted in BitcodeGotCompiled).
@@ skipping 120 matching lines @@
 
 void PnaclCoordinator::BitcodeStreamGotData(const void* data, int32_t length) {
   DCHECK(translate_thread_.get());
 
   translate_thread_->PutBytes(data, length);
   if (data && length > 0)
     pexe_size_ += length;
 }
 
 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.
     translate_finish_error_ = pp_error;
     if (pp_error == PP_ERROR_ABORTED) {
       error_info_.SetReport(PP_NACL_ERROR_PNACL_PEXE_FETCH_ABORTED,
                             "PnaclCoordinator: pexe load failed (aborted).");
     }
     if (pp_error == PP_ERROR_NOACCESS) {
@@ skipping 43 matching lines @@
   }
 }
 
 pp::CompletionCallback PnaclCoordinator::GetCompileProgressCallback(
     int64_t bytes_compiled) {
   return callback_factory_.NewCallback(&PnaclCoordinator::BitcodeGotCompiled,
                                        bytes_compiled);
 }
 
 void PnaclCoordinator::LoadCompiler() {
-  PLUGIN_PRINTF(("PnaclCoordinator::LoadCompiler"));
   base::TimeTicks compiler_load_start_time = base::TimeTicks::Now();
   pp::CompletionCallback load_finished = callback_factory_.NewCallback(
       &PnaclCoordinator::RunCompile, compiler_load_start_time);
   PnaclResources::ResourceType compiler_type = pnacl_options_.use_subzero
                                                    ? PnaclResources::SUBZERO
                                                    : PnaclResources::LLC;
   // Transfer file_info ownership to the sel_ldr launcher.
   PP_NaClFileInfo file_info = resources_->TakeFileInfo(compiler_type);
   const std::string& url = resources_->GetUrl(compiler_type);
   plugin_->LoadHelperNaClModule(url, file_info, &compiler_subprocess_,
                                 load_finished);
 }
 
 void PnaclCoordinator::RunCompile(int32_t pp_error,
                                   base::TimeTicks compiler_load_start_time) {
-  PLUGIN_PRINTF(
-      ("PnaclCoordinator::RunCompile (pp_error=%" NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_LLC_SETUP,
         "PnaclCoordinator: Compiler process could not be created.");
     return;
   }
   int64_t compiler_load_time_total =
       (base::TimeTicks::Now() - compiler_load_start_time).InMicroseconds();
   GetNaClInterface()->LogTranslateTime("NaCl.Perf.PNaClLoadTime.LoadCompiler",
                                        compiler_load_time_total);
@@ skipping 11 matching lines @@
       callback_factory_.NewCallback(&PnaclCoordinator::LoadLinker);
   CHECK(translate_thread_ != NULL);
   translate_thread_->SetupState(
       report_translate_finished, &compiler_subprocess_, &ld_subprocess_,
       &obj_files_, num_threads_, &temp_nexe_file_,
       &error_info_, &pnacl_options_, architecture_attributes_, this);
   translate_thread_->RunCompile(compile_finished);
 }
 
 void PnaclCoordinator::LoadLinker(int32_t pp_error) {
-  PLUGIN_PRINTF(
-      ("PnaclCoordinator::LoadLinker (pp_error=%" NACL_PRId32 ")\n", pp_error));
   // Errors in the previous step would have skipped to TranslateFinished
   // so we only expect PP_OK here.
   DCHECK(pp_error == PP_OK);
   if (pp_error != PP_OK) {
     return;
   }
   ErrorInfo error_info;
   base::TimeTicks ld_load_start_time = base::TimeTicks::Now();
   pp::CompletionCallback load_finished = callback_factory_.NewCallback(
       &PnaclCoordinator::RunLink, ld_load_start_time);
   // Transfer file_info ownership to the sel_ldr launcher.
   PP_NaClFileInfo ld_file_info = resources_->TakeFileInfo(PnaclResources::LD);
   plugin_->LoadHelperNaClModule(resources_->GetUrl(PnaclResources::LD),
                                 ld_file_info, &ld_subprocess_, load_finished);
 }
 
 void PnaclCoordinator::RunLink(int32_t pp_error,
                                base::TimeTicks ld_load_start_time) {
-  PLUGIN_PRINTF(
-      ("PnaclCoordinator::RunLink (pp_error=%" NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportNonPpapiError(
         PP_NACL_ERROR_PNACL_LD_SETUP,
         "PnaclCoordinator: Linker process could not be created.");
     return;
   }
   GetNaClInterface()->LogTranslateTime(
       "NaCl.Perf.PNaClLoadTime.LoadLinker",
       (base::TimeTicks::Now() - ld_load_start_time).InMicroseconds());
   translate_thread_->RunLink();
 }
 
 }  // namespace plugin