Standardize log message style for cloudprint service and display printer id

chrome/service/cloud_print/cloud_print_connector.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/cloud_print_connector.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/md5.h"
 #include "base/rand_util.h"
@@ skipping 18 matching lines @@
     cloud_print_server_url_(cloud_print_server_url),
     next_response_handler_(NULL) {
   if (print_system_settings) {
     // It is possible to have no print settings specified.
     print_system_settings_.reset(print_system_settings->DeepCopy());
   }
 }
 
 bool CloudPrintConnector::Start() {
   DCHECK(!print_system_.get());
-  VLOG(1) << "CP_CONNECTOR: Starting connector, id: " << proxy_id_;
+  VLOG(1) << "CP_CONNECTOR: Starting connector"
+          << ", proxy id: " << proxy_id_;
 
   pending_tasks_.clear();
 
   print_system_ =
       cloud_print::PrintSystem::CreateInstance(print_system_settings_.get());
   if (!print_system_.get()) {
     NOTREACHED();
     return false;  // No print system available, fail initalization.
   }
   cloud_print::PrintSystem::PrintSystemResult result = print_system_->Init();
   if (!result.succeeded()) {
     // We could not initialize the print system. We need to notify the server.
     ReportUserMessage(kPrintSystemFailedMessageId, result.message());
     print_system_.release();
     return false;
   }
 
   // Start watching for updates from the print system.
   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
   print_server_watcher_->StartWatching(this);
 
   // Get list of registered printers.
   AddPendingAvailableTask();
   return true;
 }
 
 void CloudPrintConnector::Stop() {
-  VLOG(1) << "CP_CONNECTOR: Stopping connector, id: " << proxy_id_;
+  VLOG(1) << "CP_CONNECTOR: Stopping connector"
+          << ", proxy id: " << proxy_id_;
   DCHECK(print_system_.get());
   if (print_system_.get()) {
     // Do uninitialization here.
     pending_tasks_.clear();
     print_server_watcher_.release();
     print_system_.release();
   }
   request_ = NULL;
 }
 
@@ skipping 151 matching lines @@
   ContinuePendingTaskProcessing();  // Continue processing background tasks.
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintConnector::HandlePrinterDeleteResponse(
     const net::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_CONNECTOR: Handler printer delete response, succeeded:"
-          << succeeded << " url: " << url;
+  VLOG(1) << "CP_CONNECTOR: Handler printer delete response"
+          << ", succeeded: " << succeeded
+          << ", url: " << url;
   ContinuePendingTaskProcessing();  // Continue processing background tasks.
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintConnector::HandleRegisterPrinterResponse(
     const net::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
-  VLOG(1) << "CP_CONNECTOR: Handler printer register response, succeeded:"
-          << succeeded << " url: " << url;
+  VLOG(1) << "CP_CONNECTOR: Handler printer register response"
+          << ", succeeded: " << succeeded
+          << ", url: " << url;
   if (succeeded) {
     ListValue* printer_list = NULL;
     // There should be a "printers" value in the JSON
     if (json_data->GetList(cloud_print::kPrinterListValue, &printer_list)) {
       DictionaryValue* printer_data = NULL;
       if (printer_list->GetDictionary(0, &printer_data))
         InitJobHandlerForPrinter(printer_data);
     }
   }
   ContinuePendingTaskProcessing();  // Continue processing background tasks.
@@ skipping 52 matching lines @@
   }
   return false;
 }
 
 void CloudPrintConnector::InitJobHandlerForPrinter(
     DictionaryValue* printer_data) {
   DCHECK(printer_data);
   PrinterJobHandler::PrinterInfoFromCloud printer_info_cloud;
   printer_data->GetString(kIdValue, &printer_info_cloud.printer_id);
   DCHECK(!printer_info_cloud.printer_id.empty());
-  VLOG(1) << "CP_CONNECTOR: Init job handler for printer id: "
-          << printer_info_cloud.printer_id;
+  VLOG(1) << "CP_CONNECTOR: Init job handler"
+          << ", printer id: " << printer_info_cloud.printer_id;
   JobHandlerMap::iterator index = job_handler_map_.find(
       printer_info_cloud.printer_id);
   if (index != job_handler_map_.end())
     return;  // Nothing to do if we already have a job handler for this printer.
 
   printing::PrinterBasicInfo printer_info;
   printer_data->GetString(kNameValue, &printer_info.printer_name);
   DCHECK(!printer_info.printer_name.empty());
   printer_data->GetString(kPrinterDescValue,
                           &printer_info.printer_description);
@@ skipping 143 matching lines @@
 void CloudPrintConnector::OnReceivePrinterCaps(
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   if (!IsRunning())
     return;  // Orphant call.
   DCHECK(pending_tasks_.size() > 0 &&
          pending_tasks_.front().type == PENDING_PRINTER_REGISTER);
 
   if (!succeeded) {
-    LOG(ERROR) << "CP_CONNECTOR: Failed to get printer info for: " <<
-        printer_name;
+    LOG(ERROR) << "CP_CONNECTOR: Failed to get printer info"
+               << ", printer name: " << printer_name;
     // This printer failed to register, notify the server of this failure.
     string16 printer_name_utf16 = UTF8ToUTF16(printer_name);
     std::string status_message = l10n_util::GetStringFUTF8(
         IDS_CLOUD_PRINT_REGISTER_PRINTER_FAILED,
         printer_name_utf16,
         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
     ReportUserMessage(kGetPrinterCapsFailedMessageId, status_message);
 
     ContinuePendingTaskProcessing();  // Skip this printer registration.
     return;
@@ skipping 44 matching lines @@
                    mime_type,
                    post_data,
                    &CloudPrintConnector::HandleRegisterPrinterResponse);
 }
 
 bool CloudPrintConnector::IsSamePrinter(const std::string& name1,
                                         const std::string& name2) const {
   return (0 == base::strcasecmp(name1.c_str(), name2.c_str()));
 }