Standardize log message style for cloudprint service and display printer id

chrome/service/cloud_print/print_system_cups.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 "chrome/service/cloud_print/print_system.h"
 
 #include <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 286 matching lines @@
     delegate_->OnJobChanged();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
         base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
   }
 
   void PrinterUpdate() {
     if (delegate_ == NULL)
       return;  // Orphan call. We have been stopped already.
-    VLOG(1) << "CP_CUPS: Checking for printer updates: " << printer_name_;
+    VLOG(1) << "CP_CUPS: Checking for updates"
+            << ", printer name: " << printer_name_;
     if (print_system_->NotifyDelete() &&
         !print_system_->IsValidPrinter(printer_name_)) {
       delegate_->OnPrinterDeleted();
-      VLOG(1) << "CP_CUPS: Printer deleted: " << printer_name_;
+      VLOG(1) << "CP_CUPS: Printer deleted"
+              << ", printer name: " << printer_name_;
     } else {
       std::string new_hash = GetSettingsHash();
       if (settings_hash_ != new_hash) {
         settings_hash_ = new_hash;
         delegate_->OnPrinterChanged();
-        VLOG(1) << "CP_CUPS: Printer update detected for: " << printer_name_;
+        VLOG(1) << "CP_CUPS: Printer configuration changed"
+                << ", printer name: " << printer_name_;
       }
     }
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeout());
   }
 
  protected:
   virtual ~PrinterWatcherCUPS() {
@@ skipping 152 matching lines @@
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     if (!it->backend->EnumeratePrinters(&it->printers))
       printer_enum_succeeded_ = false;
     it->caps_cache.clear();
     printing::PrinterList::iterator printer_it;
     for (printer_it = it->printers.begin();
         printer_it != it->printers.end(); ++printer_it) {
       printer_it->printer_name = MakeFullPrinterName(it->url,
                                                      printer_it->printer_name);
     }
-    VLOG(1) << "CUPS: Updated printer list for url: " << it->url
-            << " Number of printers: " << it->printers.size();
+    VLOG(1) << "CP_CUPS: Updated printers list"
+            << ", server: " << it->url
+            << ", # of printers: " << it->printers.size();
   }
 
   // Schedule next update.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PrintSystemCUPS::UpdatePrinters, this), GetUpdateTimeout());
 }
 
 PrintSystem::PrintSystemResult PrintSystemCUPS::EnumeratePrinters(
     printing::PrinterList* printer_list) {
   DCHECK(initialized_);
   printer_list->clear();
   PrintServerList::iterator it;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     printer_list->insert(printer_list->end(),
         it->printers.begin(), it->printers.end());
   }
-  VLOG(1) << "CUPS: Total " << printer_list->size() << " printers enumerated.";
+  VLOG(1) << "CP_CUPS: Total printers enumerated: " << printer_list->size();
   // TODO(sanjeevr): Maybe some day we want to report the actual server names
   // for which the enumeration failed.
   return PrintSystemResult(printer_enum_succeeded_, std::string());
 }
 
 void PrintSystemCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
     const PrinterCapsAndDefaultsCallback& callback) {
   printing::PrinterCapsAndDefaults printer_info;
   bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
@@ skipping 79 matching lines @@
   if (!server_info)
     return false;
 
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       server_info->backend->GetPrinterDriverInfo(short_printer_name));
   cups_job_t* jobs = NULL;
   int num_jobs = GetJobs(&jobs, server_info->url, cups_encryption_,
                          short_printer_name.c_str(), 1, -1);
   bool error = (num_jobs == 0) && (cupsLastError() > IPP_OK_EVENTS_COMPLETE);
   if (error) {
-    VLOG(1) << "CP_CUPS: Error getting jobs from CUPS server. Printer:"
-            << printer_name
-            << " Error: "
-            << static_cast<int>(cupsLastError());
+    VLOG(1) << "CP_CUPS: Error getting jobs from CUPS server"
+            << ", printer name:" << printer_name
+            << ", error: " << static_cast<int>(cupsLastError());
     return false;
   }
 
   // Check if the request is for dummy dry run job.
   // We check this after calling GetJobs API to see if this printer is actually
   // accessible through CUPS.
   if (job_id == kDryRunJobId) {
     job_details->status = PRINT_JOB_STATUS_COMPLETED;
-    VLOG(1) << "CP_CUPS: Dry run job succeeded for: " << printer_name;
+    VLOG(1) << "CP_CUPS: Dry run job succeeded"
+            << ", printer name: " << printer_name;
     return true;
   }
 
   bool found = false;
   for (int i = 0; i < num_jobs; i++) {
     if (jobs[i].id == job_id) {
       found = true;
       switch (jobs[i].state) {
         case IPP_JOB_PENDING :
         case IPP_JOB_HELD :
@@ skipping 12 matching lines @@
           job_details->status = PRINT_JOB_STATUS_INVALID;
       }
       job_details->platform_status_flags = jobs[i].state;
 
       // We don't have any details on the number of processed pages here.
       break;
     }
   }
 
   if (found)
-    VLOG(1) << "CP_CUPS: Job details for: " << printer_name
-            << " job_id: " << job_id << " job status: " << job_details->status;
+    VLOG(1) << "CP_CUPS: Job found"
+            << ", printer name: " << printer_name
+            << ", cups job id: " << job_id
+            << ", cups job status: " << job_details->status;
   else
-    LOG(WARNING) << "CP_CUPS: Job not found for: " << printer_name
-                 << " job_id: " << job_id;
+    LOG(WARNING) << "CP_CUPS: Job not found"
+                 << ", printer name: " << printer_name
+                 << ", cups job id: " << job_id;
 
   cupsFreeJobs(num_jobs, jobs);
   return found;
 }
 
 bool PrintSystemCUPS::GetPrinterInfo(const std::string& printer_name,
                                      printing::PrinterBasicInfo* info) {
   DCHECK(initialized_);
   if (info)
-    VLOG(1) << "CP_CUPS: Getting printer info for: " << printer_name;
+    VLOG(1) << "CP_CUPS: Getting printer info"
+            << ", printer name: " << printer_name;
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
   printing::PrinterList::iterator it;
   for (it = server_info->printers.begin();
       it != server_info->printers.end(); ++it) {
@@ skipping 74 matching lines @@
 
 PlatformJobId PrintSystemCUPS::SpoolPrintJob(
     const std::string& print_ticket,
     const FilePath& print_data_file_path,
     const std::string& print_data_mime_type,
     const std::string& printer_name,
     const std::string& job_title,
     const std::vector<std::string>& tags,
     bool* dry_run) {
   DCHECK(initialized_);
-  VLOG(1) << "CP_CUPS: Spooling print job for: " << printer_name;
+  VLOG(1) << "CP_CUPS: Spooling print job, printer name: " << printer_name;
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
   child_process_logging::ScopedPrinterInfoSetter prn_info(
       server_info->backend->GetPrinterDriverInfo(printer_name));
 
   // We need to store options as char* string for the duration of the
   // cupsPrintFile2 call. We'll use map here to store options, since
   // Dictionary value from JSON parser returns wchat_t.
   std::map<std::string, std::string> options;
   bool res = ParsePrintTicket(print_ticket, &options);
   DCHECK(res);  // If print ticket is invalid we still print using defaults.
 
   // Check if this is a dry run (test) job.
   *dry_run = CloudPrintHelpers::IsDryRunJob(tags);
   if (*dry_run) {
-    VLOG(1) << "CP_CUPS: Dry run job spooled.";
+    VLOG(1) << "CP_CUPS: Dry run job spooled";
     return kDryRunJobId;
   }
 
   std::vector<cups_option_t> cups_options;
   std::map<std::string, std::string>::iterator it;
 
   for (it = options.begin(); it != options.end(); ++it) {
     cups_option_t opt;
     opt.name = const_cast<char*>(it->first.c_str());
     opt.value = const_cast<char*>(it->second.c_str());
     cups_options.push_back(opt);
   }
 
   int job_id = PrintFile(server_info->url,
                          cups_encryption_,
                          short_printer_name.c_str(),
                          print_data_file_path.value().c_str(),
                          job_title.c_str(),
                          cups_options.size(),
                          &(cups_options[0]));
 
-  VLOG(1) << "CP_CUPS: Job spooled, id: " << job_id;
+  // TODO(alexyu): Output printer id.
+  VLOG(1) << "CP_CUPS: Job spooled"
+          << ", printer name: " << printer_name
+          << ", cups job id: " << job_id;
 
   return job_id;
 }
 
 std::string PrintSystemCUPS::MakeFullPrinterName(
     const GURL& url, const std::string& short_printer_name) {
   std::string full_name;
   full_name += "\\\\";
   full_name += url.host();
   if (!url.port().empty()) {
     full_name += ":";
     full_name += url.port();
   }
   full_name += "\\";
   full_name += short_printer_name;
   return full_name;
 }
 
 PrintServerInfoCUPS* PrintSystemCUPS::FindServerByFullName(
     const std::string& full_printer_name, std::string* short_printer_name) {
   size_t front = full_printer_name.find("\\\\");
   size_t separator = full_printer_name.find("\\", 2);
   if (front == std::string::npos || separator == std::string::npos) {
-    LOG(WARNING) << "Invalid UNC printer name: " << full_printer_name;
+    LOG(WARNING) << "CP_CUPS: Invalid UNC"
+                 << ", printer name: " << full_printer_name;
     return NULL;
   }
   std::string server = full_printer_name.substr(2, separator - 2);
 
   PrintServerList::iterator it;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     std::string cur_server;
     cur_server += it->url.host();
     if (!it->url.port().empty()) {
       cur_server += ":";
       cur_server += it->url.port();
     }
     if (cur_server == server) {
       *short_printer_name = full_printer_name.substr(separator + 1);
       return &(*it);
     }
   }
 
-  LOG(WARNING) << "Server not found for printer: " << full_printer_name;
+  LOG(WARNING) << "CP_CUPS: Server not found"
+               << ", printer name: " << full_printer_name;
   return NULL;
 }
 
 void PrintSystemCUPS::RunCapsCallback(
     const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print