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

components/nacl/renderer/plugin/pnacl_translate_thread.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_translate_thread.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <sstream>
@@ skipping 69 matching lines @@
     const pp::CompletionCallback& finish_callback,
     NaClSubprocess* compiler_subprocess,
     NaClSubprocess* ld_subprocess,
     std::vector<base::File>* obj_files,
     int num_threads,
     base::File* nexe_file,
     ErrorInfo* error_info,
     PP_PNaClOptions* pnacl_options,
     const std::string& architecture_attributes,
     PnaclCoordinator* coordinator) {
-  PLUGIN_PRINTF(("PnaclTranslateThread::SetupState)\n"));
   compiler_subprocess_ = compiler_subprocess;
   ld_subprocess_ = ld_subprocess;
   obj_files_ = obj_files;
   num_threads_ = num_threads;
   nexe_file_ = nexe_file;
   coordinator_error_info_ = error_info;
   pnacl_options_ = pnacl_options;
   architecture_attributes_ = architecture_attributes;
   coordinator_ = coordinator;
 
   report_translate_finished_ = finish_callback;
 }
 
 void PnaclTranslateThread::RunCompile(
     const pp::CompletionCallback& compile_finished_callback) {
-  PLUGIN_PRINTF(("PnaclTranslateThread::RunCompile)\n"));
   DCHECK(started());
   DCHECK(compiler_subprocess_->service_runtime());
   compiler_subprocess_active_ = true;
 
   // Take ownership of this IPC channel to make sure that it does not get
   // freed on the child thread when the child thread calls Shutdown().
   compiler_channel_ =
       compiler_subprocess_->service_runtime()->TakeTranslatorChannel();
   // compiler_channel_ is a IPC::SyncChannel, which is not thread-safe and
   // cannot be used directly by the child thread, so create a
   // SyncMessageFilter which can be used by the child thread.
   compiler_channel_filter_ = compiler_channel_->CreateSyncMessageFilter();
   // Make a copy of the process ID, again to avoid any thread-safety issues
   // involved in accessing compiler_subprocess_ on the child thread.
   compiler_channel_peer_pid_ =
       compiler_subprocess_->service_runtime()->get_process_id();
 
   compile_finished_callback_ = compile_finished_callback;
   translate_thread_.reset(new CompileThread(this));
   translate_thread_->Start();
 }
 
 void PnaclTranslateThread::RunLink() {
-  PLUGIN_PRINTF(("PnaclTranslateThread::RunLink)\n"));
   DCHECK(started());
   DCHECK(ld_subprocess_->service_runtime());
   ld_subprocess_active_ = true;
 
   // Take ownership of this IPC channel to make sure that it does not get
   // freed on the child thread when the child thread calls Shutdown().
   ld_channel_ = ld_subprocess_->service_runtime()->TakeTranslatorChannel();
   // ld_channel_ is a IPC::SyncChannel, which is not thread-safe and cannot be
   // used directly by the child thread, so create a SyncMessageFilter which
   // can be used by the child thread.
@@ skipping 64 matching lines @@
       return;
   }
 
   std::vector<ppapi::proxy::SerializedHandle> compiler_output_files;
   for (base::File& obj_file : *obj_files_) {
     compiler_output_files.push_back(
         GetHandleForSubprocess(&obj_file, PP_FILEOPENFLAG_WRITE,
                                compiler_channel_peer_pid_));
   }
 
-  PLUGIN_PRINTF(("DoCompile using subzero: %d\n", pnacl_options_->use_subzero));
-
   pp::Core* core = pp::Module::Get()->core();
   base::TimeTicks do_compile_start_time = base::TimeTicks::Now();
 
   std::vector<std::string> args;
   if (pnacl_options_->use_subzero) {
     GetSubzeroCommandLine(&args, pnacl_options_->opt_level,
                           PP_ToBool(pnacl_options_->is_debug),
                           architecture_attributes_);
   } else {
     GetLlcCommandLine(&args, obj_files_->size(),
@@ skipping 11 matching lines @@
                     "Compile stream init failed: "
                     "reply not received from PNaCl translator "
                     "(it probably crashed)");
     return;
   }
   if (!success) {
     TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                     std::string("Stream init failed: ") + error_str);
     return;
   }
-  PLUGIN_PRINTF(("PnaclCoordinator: StreamInit successful\n"));
 
   // llc process is started.
   while(!done_ || data_buffers_.size() > 0) {
     cond_mu_.Acquire();
     while(!done_ && data_buffers_.size() == 0) {
       buffer_cond_.Wait();
     }
-    PLUGIN_PRINTF(("PnaclTranslateThread awake (done=%d, size=%" NACL_PRIuS
-                   ")\n",
-                   done_, data_buffers_.size()));
     if (data_buffers_.size() > 0) {
       std::string data;
       data.swap(data_buffers_.front());
       data_buffers_.pop_front();
       cond_mu_.Release();
-      PLUGIN_PRINTF(("StreamChunk\n"));
 
       if (!compiler_channel_filter_->Send(
               new PpapiMsg_PnaclTranslatorCompileChunk(data, &success))) {
         TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                         "Compile stream chunk failed: "
                         "reply not received from PNaCl translator "
                         "(it probably crashed)");
         return;
       }
       if (!success) {
         // If the error was reported by the translator, then we fall through
         // and call PpapiMsg_PnaclTranslatorCompileEnd, which returns a string
         // describing the error, which we can then send to the Javascript
         // console.
         break;
       }
-      PLUGIN_PRINTF(("StreamChunk Successful\n"));
       core->CallOnMainThread(
           0,
           coordinator_->GetCompileProgressCallback(data.size()),
           PP_OK);
     } else {
       cond_mu_.Release();
     }
   }
-  PLUGIN_PRINTF(("PnaclTranslateThread done with chunks\n"));
   // Finish llc.
   if (!compiler_channel_filter_->Send(
           new PpapiMsg_PnaclTranslatorCompileEnd(&success, &error_str))) {
     TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                     "Compile stream end failed: "
                     "reply not received from PNaCl translator "
                     "(it probably crashed)");
     return;
   }
   if (!success) {
@@ skipping 65 matching lines @@
   }
   if (!success) {
     TranslateFailed(PP_NACL_ERROR_PNACL_LD_INTERNAL,
                     "link failed: linker returned failure status.");
     return;
   }
 
   GetNaClInterface()->LogTranslateTime(
       "NaCl.Perf.PNaClLoadTime.LinkTime",
       (base::TimeTicks::Now() - link_start_time).InMicroseconds());
-  PLUGIN_PRINTF(("PnaclCoordinator: link (translator=%p) succeeded\n",
-                 this));
 
   // Shut down the ld subprocess.
   {
     base::AutoLock lock(subprocess_mu_);
     ld_subprocess_active_ = false;
     ld_subprocess_->Shutdown();
   }
 
   pp::Core* core = pp::Module::Get()->core();
   core->CallOnMainThread(0, report_translate_finished_, PP_OK);
 }
 
 void PnaclTranslateThread::TranslateFailed(
     PP_NaClError err_code,
     const std::string& error_string) {
-  PLUGIN_PRINTF(("PnaclTranslateThread::TranslateFailed (error_string='%s')\n",
-                 error_string.c_str()));
   pp::Core* core = pp::Module::Get()->core();
   if (coordinator_error_info_->message().empty()) {
     // Only use our message if one hasn't already been set by the coordinator
     // (e.g. pexe load failed).
     coordinator_error_info_->SetReport(err_code,
                                        std::string("PnaclCoordinator: ") +
                                        error_string);
   }
   core->CallOnMainThread(0, report_translate_finished_, PP_ERROR_FAILED);
 }
 
 void PnaclTranslateThread::AbortSubprocesses() {
-  PLUGIN_PRINTF(("PnaclTranslateThread::AbortSubprocesses\n"));
   {
     base::AutoLock lock(subprocess_mu_);
     if (compiler_subprocess_ != NULL && compiler_subprocess_active_) {
       // We only run the service_runtime's Shutdown and do not run the
       // NaClSubprocess Shutdown, which would otherwise nullify some
       // pointers that could still be in use (srpc_client, etc.).
       compiler_subprocess_->service_runtime()->Shutdown();
       compiler_subprocess_active_ = false;
     }
     if (ld_subprocess_ != NULL && ld_subprocess_active_) {
       ld_subprocess_->service_runtime()->Shutdown();
       ld_subprocess_active_ = false;
     }
   }
   base::AutoLock lock(cond_mu_);
   done_ = true;
   // Free all buffered bitcode chunks
   data_buffers_.clear();
   buffer_cond_.Signal();
 }
 
 PnaclTranslateThread::~PnaclTranslateThread() {
-  PLUGIN_PRINTF(("~PnaclTranslateThread (translate_thread=%p)\n", this));
   AbortSubprocesses();
   if (translate_thread_)
     translate_thread_->Join();
-  PLUGIN_PRINTF(("~PnaclTranslateThread joined\n"));
 }
 
 } // namespace plugin