chrome/service/cloud_print/cloud_print_connector.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/service/cloud_print/cloud_print_connector.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/md5.h"
  10 #include "base/rand_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/values.h"
  17 #include "chrome/common/cloud_print/cloud_print_constants.h"
  18 #include "chrome/common/cloud_print/cloud_print_helpers.h"
  19 #include "chrome/grit/generated_resources.h"
  20 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
  21 #include "net/base/mime_util.h"
  22 #include "ui/base/l10n/l10n_util.h"
  23
  24 namespace cloud_print {
  25
  26 CloudPrintConnector::CloudPrintConnector(Client* client,
  27                                          const ConnectorSettings& settings)
  28   : client_(client),
  29     next_response_handler_(NULL),
  30     stats_ptr_factory_(this) {
  31   settings_.CopyFrom(settings);
  32 }
  33
  34 bool CloudPrintConnector::InitPrintSystem() {
  35   if (print_system_.get())
  36     return true;
  37   print_system_ = PrintSystem::CreateInstance(
  38       settings_.print_system_settings());
  39   if (!print_system_.get()) {
  40     NOTREACHED();
  41     return false;  // No memory.
  42   }
  43   PrintSystem::PrintSystemResult result = print_system_->Init();
  44   if (!result.succeeded()) {
  45     print_system_ = NULL;
  46     // We could not initialize the print system. We need to notify the server.
  47     ReportUserMessage(kPrintSystemFailedMessageId, result.message());
  48     return false;
  49   }
  50   return true;
  51 }
  52
  53 void CloudPrintConnector::ScheduleStatsReport() {
  54   base::MessageLoop::current()->PostDelayedTask(
  55       FROM_HERE,
  56       base::Bind(&CloudPrintConnector::ReportStats,
  57                  stats_ptr_factory_.GetWeakPtr()),
  58       base::TimeDelta::FromHours(1));
  59 }
  60
  61 void CloudPrintConnector::ReportStats() {
  62   PrinterJobHandler::ReportsStats();
  63   ScheduleStatsReport();
  64 }
  65
  66 bool CloudPrintConnector::Start() {
  67   VLOG(1) << "CP_CONNECTOR: Starting connector"
  68           << ", proxy id: " << settings_.proxy_id();
  69
  70   pending_tasks_.clear();
  71
  72   if (!InitPrintSystem())
  73     return false;
  74
  75   ScheduleStatsReport();
  76
  77   // Start watching for updates from the print system.
  78   print_server_watcher_ = print_system_->CreatePrintServerWatcher();
  79   print_server_watcher_->StartWatching(this);
  80
  81   // Get list of registered printers.
  82   AddPendingAvailableTask();
  83   return true;
  84 }
  85
  86 void CloudPrintConnector::Stop() {
  87   VLOG(1) << "CP_CONNECTOR: Stopping connector"
  88           << ", proxy id: " << settings_.proxy_id();
  89   DCHECK(IsRunning());
  90   // Do uninitialization here.
  91   stats_ptr_factory_.InvalidateWeakPtrs();
  92   pending_tasks_.clear();
  93   print_server_watcher_ = NULL;
  94   request_ = NULL;
  95 }
  96
  97 bool CloudPrintConnector::IsRunning() {
  98   return print_server_watcher_.get() != NULL;
  99 }
 100
 101 void CloudPrintConnector::GetPrinterIds(std::list<std::string>* printer_ids) {
 102   DCHECK(printer_ids);
 103   printer_ids->clear();
 104   for (JobHandlerMap::const_iterator iter = job_handler_map_.begin();
 105        iter != job_handler_map_.end(); ++iter) {
 106     printer_ids->push_back(iter->first);
 107   }
 108 }
 109
 110 void CloudPrintConnector::RegisterPrinters(
 111     const printing::PrinterList& printers) {
 112   if (!IsRunning())
 113     return;
 114   printing::PrinterList::const_iterator it;
 115   for (it = printers.begin(); it != printers.end(); ++it) {
 116     if (settings_.ShouldConnect(it->printer_name))
 117       AddPendingRegisterTask(*it);
 118   }
 119 }
 120
 121 // Check for jobs for specific printer
 122 void CloudPrintConnector::CheckForJobs(const std::string& reason,
 123                                        const std::string& printer_id) {
 124   if (!IsRunning())
 125     return;
 126   if (!printer_id.empty()) {
 127     JobHandlerMap::iterator index = job_handler_map_.find(printer_id);
 128     if (index != job_handler_map_.end()) {
 129       index->second->CheckForJobs(reason);
 130     } else {
 131       std::string status_message = l10n_util::GetStringUTF8(
 132           IDS_CLOUD_PRINT_ZOMBIE_PRINTER);
 133       LOG(ERROR) << "CP_CONNECTOR: " << status_message <<
 134           " Printer_id: " << printer_id;
 135       ReportUserMessage(kZombiePrinterMessageId, status_message);
 136     }
 137   } else {
 138     for (JobHandlerMap::iterator index = job_handler_map_.begin();
 139          index != job_handler_map_.end(); index++) {
 140       index->second->CheckForJobs(reason);
 141     }
 142   }
 143 }
 144
 145 void CloudPrintConnector::UpdatePrinterSettings(const std::string& printer_id) {
 146   // Since connector is managing many printers we need to go through all of them
 147   // to select the correct settings.
 148   GURL printer_list_url = GetUrlForPrinterList(
 149       settings_.server_url(), settings_.proxy_id());
 150   StartGetRequest(
 151       printer_list_url,
 152       kCloudPrintRegisterMaxRetryCount,
 153       &CloudPrintConnector::HandlePrinterListResponseSettingsUpdate);
 154 }
 155
 156 void CloudPrintConnector::OnPrinterAdded() {
 157   AddPendingAvailableTask();
 158 }
 159
 160 void CloudPrintConnector::OnPrinterDeleted(const std::string& printer_id) {
 161   AddPendingDeleteTask(printer_id);
 162 }
 163
 164 void CloudPrintConnector::OnAuthError() {
 165   client_->OnAuthFailed();
 166 }
 167
 168 // CloudPrintURLFetcher::Delegate implementation.
 169 CloudPrintURLFetcher::ResponseAction CloudPrintConnector::HandleRawData(
 170     const net::URLFetcher* source,
 171     const GURL& url,
 172     const std::string& data) {
 173   // If this notification came as a result of user message call, stop it.
 174   // Otherwise proceed continue processing.
 175   if (user_message_request_.get() &&
 176       user_message_request_->IsSameRequest(source))
 177     return CloudPrintURLFetcher::STOP_PROCESSING;
 178   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 179 }
 180
 181 CloudPrintURLFetcher::ResponseAction CloudPrintConnector::HandleJSONData(
 182     const net::URLFetcher* source,
 183     const GURL& url,
 184     base::DictionaryValue* json_data,
 185     bool succeeded) {
 186   if (!IsRunning())  // Orphant response. Connector has been stopped already.
 187     return CloudPrintURLFetcher::STOP_PROCESSING;
 188
 189   DCHECK(next_response_handler_);
 190   return (this->*next_response_handler_)(source, url, json_data, succeeded);
 191 }
 192
 193 CloudPrintURLFetcher::ResponseAction CloudPrintConnector::OnRequestAuthError() {
 194   OnAuthError();
 195   return CloudPrintURLFetcher::STOP_PROCESSING;
 196 }
 197
 198 std::string CloudPrintConnector::GetAuthHeader() {
 199   return GetCloudPrintAuthHeaderFromStore();
 200 }
 201
 202 CloudPrintConnector::~CloudPrintConnector() {}
 203
 204 CloudPrintURLFetcher::ResponseAction
 205 CloudPrintConnector::HandlePrinterListResponse(
 206     const net::URLFetcher* source,
 207     const GURL& url,
 208     base::DictionaryValue* json_data,
 209     bool succeeded) {
 210   DCHECK(succeeded);
 211   if (!succeeded)
 212     return CloudPrintURLFetcher::RETRY_REQUEST;
 213
 214   UpdateSettingsFromPrintersList(json_data);
 215
 216   // Now we need to get the list of printers from the print system
 217   // and split printers into 3 categories:
 218   // - existing and registered printers
 219   // - new printers
 220   // - deleted printers
 221
 222   // Get list of the printers from the print system.
 223   printing::PrinterList local_printers;
 224   PrintSystem::PrintSystemResult result =
 225       print_system_->EnumeratePrinters(&local_printers);
 226   bool full_list = result.succeeded();
 227   if (!full_list) {
 228     std::string message = result.message();
 229     if (message.empty())
 230       message = l10n_util::GetStringFUTF8(IDS_CLOUD_PRINT_ENUM_FAILED,
 231           l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
 232     // There was a failure enumerating printers. Send a message to the server.
 233     ReportUserMessage(kEnumPrintersFailedMessageId, message);
 234   }
 235
 236   // Go through the list of the cloud printers and init print job handlers.
 237   base::ListValue* printer_list = NULL;
 238   // There may be no "printers" value in the JSON
 239   if (json_data->GetList(kPrinterListValue, &printer_list) && printer_list) {
 240     for (size_t index = 0; index < printer_list->GetSize(); index++) {
 241       base::DictionaryValue* printer_data = NULL;
 242       if (printer_list->GetDictionary(index, &printer_data)) {
 243         std::string printer_name;
 244         printer_data->GetString(kNameValue, &printer_name);
 245         std::string printer_id;
 246         printer_data->GetString(kIdValue, &printer_id);
 247
 248         if (!settings_.ShouldConnect(printer_name)) {
 249           VLOG(1) << "CP_CONNECTOR: Deleting " << printer_name <<
 250               " id: " << printer_id << " as blacklisted";
 251           AddPendingDeleteTask(printer_id);
 252         } else if (RemovePrinterFromList(printer_name, &local_printers)) {
 253           InitJobHandlerForPrinter(printer_data);
 254         } else {
 255           // Cloud printer is not found on the local system.
 256           if (full_list || settings_.delete_on_enum_fail()) {
 257             // Delete if we get the full list of printers or
 258             // |delete_on_enum_fail_| is set.
 259             VLOG(1) << "CP_CONNECTOR: Deleting " << printer_name <<
 260                 " id: " << printer_id <<
 261                 " full_list: " << full_list <<
 262                 " delete_on_enum_fail: " << settings_.delete_on_enum_fail();
 263             AddPendingDeleteTask(printer_id);
 264           } else {
 265             LOG(ERROR) << "CP_CONNECTOR: Printer: " << printer_name <<
 266                 " id: " << printer_id <<
 267                 " not found in print system and full printer list was" <<
 268                 " not received.  Printer will not be able to process" <<
 269                 " jobs.";
 270           }
 271         }
 272       } else {
 273         NOTREACHED();
 274       }
 275     }
 276   }
 277
 278   request_ = NULL;
 279
 280   RegisterPrinters(local_printers);
 281   ContinuePendingTaskProcessing();  // Continue processing background tasks.
 282   return CloudPrintURLFetcher::STOP_PROCESSING;
 283 }
 284
 285 CloudPrintURLFetcher::ResponseAction
 286 CloudPrintConnector::HandlePrinterListResponseSettingsUpdate(
 287     const net::URLFetcher* source,
 288     const GURL& url,
 289     base::DictionaryValue* json_data,
 290     bool succeeded) {
 291   DCHECK(succeeded);
 292   if (!succeeded)
 293     return CloudPrintURLFetcher::RETRY_REQUEST;
 294
 295   UpdateSettingsFromPrintersList(json_data);
 296   return CloudPrintURLFetcher::STOP_PROCESSING;
 297 }
 298
 299 CloudPrintURLFetcher::ResponseAction
 300 CloudPrintConnector::HandlePrinterDeleteResponse(
 301     const net::URLFetcher* source,
 302     const GURL& url,
 303     base::DictionaryValue* json_data,
 304     bool succeeded) {
 305   VLOG(1) << "CP_CONNECTOR: Handler printer delete response"
 306           << ", succeeded: " << succeeded
 307           << ", url: " << url;
 308   ContinuePendingTaskProcessing();  // Continue processing background tasks.
 309   return CloudPrintURLFetcher::STOP_PROCESSING;
 310 }
 311
 312 CloudPrintURLFetcher::ResponseAction
 313 CloudPrintConnector::HandleRegisterPrinterResponse(
 314     const net::URLFetcher* source,
 315     const GURL& url,
 316     base::DictionaryValue* json_data,
 317     bool succeeded) {
 318   VLOG(1) << "CP_CONNECTOR: Handler printer register response"
 319           << ", succeeded: " << succeeded
 320           << ", url: " << url;
 321   if (succeeded) {
 322     base::ListValue* printer_list = NULL;
 323     // There should be a "printers" value in the JSON
 324     if (json_data->GetList(kPrinterListValue, &printer_list)) {
 325       base::DictionaryValue* printer_data = NULL;
 326       if (printer_list->GetDictionary(0, &printer_data))
 327         InitJobHandlerForPrinter(printer_data);
 328     }
 329   }
 330   ContinuePendingTaskProcessing();  // Continue processing background tasks.
 331   return CloudPrintURLFetcher::STOP_PROCESSING;
 332 }
 333
 334
 335 void CloudPrintConnector::StartGetRequest(const GURL& url,
 336                                           int max_retries,
 337                                           ResponseHandler handler) {
 338   next_response_handler_ = handler;
 339   request_ = CloudPrintURLFetcher::Create();
 340   request_->StartGetRequest(CloudPrintURLFetcher::REQUEST_UPDATE_JOB,
 341                             url, this, max_retries, std::string());
 342 }
 343
 344 void CloudPrintConnector::StartPostRequest(
 345     CloudPrintURLFetcher::RequestType type,
 346     const GURL& url,
 347     int max_retries,
 348     const std::string& mime_type,
 349     const std::string& post_data,
 350     ResponseHandler handler) {
 351   next_response_handler_ = handler;
 352   request_ = CloudPrintURLFetcher::Create();
 353   request_->StartPostRequest(
 354       type, url, this, max_retries, mime_type, post_data, std::string());
 355 }
 356
 357 void CloudPrintConnector::ReportUserMessage(const std::string& message_id,
 358                                             const std::string& failure_msg) {
 359   // This is a fire and forget type of function.
 360   // Result of this request will be ignored.
 361   std::string mime_boundary;
 362   CreateMimeBoundaryForUpload(&mime_boundary);
 363   GURL url = GetUrlForUserMessage(settings_.server_url(), message_id);
 364   std::string post_data;
 365   net::AddMultipartValueForUpload(kMessageTextValue, failure_msg, mime_boundary,
 366                                   std::string(), &post_data);
 367   net::AddMultipartFinalDelimiterForUpload(mime_boundary, &post_data);
 368   std::string mime_type("multipart/form-data; boundary=");
 369   mime_type += mime_boundary;
 370   user_message_request_ = CloudPrintURLFetcher::Create();
 371   user_message_request_->StartPostRequest(
 372       CloudPrintURLFetcher::REQUEST_USER_MESSAGE, url, this, 1, mime_type,
 373       post_data, std::string());
 374 }
 375
 376 bool CloudPrintConnector::RemovePrinterFromList(
 377     const std::string& printer_name,
 378     printing::PrinterList* printer_list) {
 379   for (printing::PrinterList::iterator index = printer_list->begin();
 380        index != printer_list->end(); index++) {
 381     if (IsSamePrinter(index->printer_name, printer_name)) {
 382       index = printer_list->erase(index);
 383       return true;
 384     }
 385   }
 386   return false;
 387 }
 388
 389 void CloudPrintConnector::InitJobHandlerForPrinter(
 390     base::DictionaryValue* printer_data) {
 391   DCHECK(printer_data);
 392   PrinterJobHandler::PrinterInfoFromCloud printer_info_cloud;
 393   printer_data->GetString(kIdValue, &printer_info_cloud.printer_id);
 394   DCHECK(!printer_info_cloud.printer_id.empty());
 395   VLOG(1) << "CP_CONNECTOR: Init job handler"
 396           << ", printer id: " << printer_info_cloud.printer_id;
 397   JobHandlerMap::iterator index = job_handler_map_.find(
 398       printer_info_cloud.printer_id);
 399   if (index != job_handler_map_.end())
 400     return;  // Nothing to do if we already have a job handler for this printer.
 401
 402   printing::PrinterBasicInfo printer_info;
 403   printer_data->GetString(kNameValue, &printer_info.printer_name);
 404   DCHECK(!printer_info.printer_name.empty());
 405   printer_data->GetString(kPrinterDescValue,
 406                           &printer_info.printer_description);
 407   // Printer status is a string value which actually contains an integer.
 408   std::string printer_status;
 409   if (printer_data->GetString(kPrinterStatusValue, &printer_status)) {
 410     base::StringToInt(printer_status, &printer_info.printer_status);
 411   }
 412   printer_data->GetString(kPrinterCapsHashValue,
 413       &printer_info_cloud.caps_hash);
 414   base::ListValue* tags_list = NULL;
 415   if (printer_data->GetList(kTagsValue, &tags_list) && tags_list) {
 416     for (size_t index = 0; index < tags_list->GetSize(); index++) {
 417       std::string tag;
 418       if (tags_list->GetString(index, &tag) &&
 419           StartsWithASCII(tag, kCloudPrintServiceTagsHashTagName, false)) {
 420         std::vector<std::string> tag_parts;
 421         base::SplitStringDontTrim(tag, '=', &tag_parts);
 422         DCHECK_EQ(tag_parts.size(), 2U);
 423         if (tag_parts.size() == 2)
 424           printer_info_cloud.tags_hash = tag_parts[1];
 425       }
 426     }
 427   }
 428
 429   int xmpp_timeout = 0;
 430   printer_data->GetInteger(kLocalSettingsPendingXmppValue, &xmpp_timeout);
 431   printer_info_cloud.current_xmpp_timeout = settings_.xmpp_ping_timeout_sec();
 432   printer_info_cloud.pending_xmpp_timeout = xmpp_timeout;
 433
 434   scoped_refptr<PrinterJobHandler> job_handler;
 435   job_handler = new PrinterJobHandler(printer_info,
 436                                       printer_info_cloud,
 437                                       settings_.server_url(),
 438                                       print_system_.get(),
 439                                       this);
 440   job_handler_map_[printer_info_cloud.printer_id] = job_handler;
 441   job_handler->Initialize();
 442 }
 443
 444 void CloudPrintConnector::UpdateSettingsFromPrintersList(
 445     base::DictionaryValue* json_data) {
 446   base::ListValue* printer_list = NULL;
 447   int min_xmpp_timeout = std::numeric_limits<int>::max();
 448   // There may be no "printers" value in the JSON
 449   if (json_data->GetList(kPrinterListValue, &printer_list) && printer_list) {
 450     for (size_t index = 0; index < printer_list->GetSize(); index++) {
 451       base::DictionaryValue* printer_data = NULL;
 452       if (printer_list->GetDictionary(index, &printer_data)) {
 453         int xmpp_timeout = 0;
 454         if (printer_data->GetInteger(kLocalSettingsPendingXmppValue,
 455                                      &xmpp_timeout)) {
 456           min_xmpp_timeout = std::min(xmpp_timeout, min_xmpp_timeout);
 457         }
 458       }
 459     }
 460   }
 461
 462   if (min_xmpp_timeout != std::numeric_limits<int>::max()) {
 463     DCHECK(min_xmpp_timeout >= kMinXmppPingTimeoutSecs);
 464     settings_.SetXmppPingTimeoutSec(min_xmpp_timeout);
 465     client_->OnXmppPingUpdated(min_xmpp_timeout);
 466   }
 467 }
 468
 469
 470 void CloudPrintConnector::AddPendingAvailableTask() {
 471   PendingTask task;
 472   task.type = PENDING_PRINTERS_AVAILABLE;
 473   AddPendingTask(task);
 474 }
 475
 476 void CloudPrintConnector::AddPendingDeleteTask(const std::string& id) {
 477   PendingTask task;
 478   task.type = PENDING_PRINTER_DELETE;
 479   task.printer_id = id;
 480   AddPendingTask(task);
 481 }
 482
 483 void CloudPrintConnector::AddPendingRegisterTask(
 484     const printing::PrinterBasicInfo& info) {
 485   PendingTask task;
 486   task.type = PENDING_PRINTER_REGISTER;
 487   task.printer_info = info;
 488   AddPendingTask(task);
 489 }
 490
 491 void CloudPrintConnector::AddPendingTask(const PendingTask& task) {
 492   pending_tasks_.push_back(task);
 493   // If this is the only pending task, we need to start the process.
 494   if (pending_tasks_.size() == 1) {
 495     base::MessageLoop::current()->PostTask(
 496         FROM_HERE, base::Bind(&CloudPrintConnector::ProcessPendingTask, this));
 497   }
 498 }
 499
 500 void CloudPrintConnector::ProcessPendingTask() {
 501   if (!IsRunning())
 502     return;  // Orphant call.
 503   if (pending_tasks_.size() == 0)
 504     return;  // No peding tasks.
 505
 506   PendingTask task = pending_tasks_.front();
 507
 508   switch (task.type) {
 509     case PENDING_PRINTERS_AVAILABLE :
 510       OnPrintersAvailable();
 511       break;
 512     case PENDING_PRINTER_REGISTER :
 513       OnPrinterRegister(task.printer_info);
 514       break;
 515     case PENDING_PRINTER_DELETE :
 516       OnPrinterDelete(task.printer_id);
 517       break;
 518     default:
 519       NOTREACHED();
 520   }
 521 }
 522
 523 void CloudPrintConnector::ContinuePendingTaskProcessing() {
 524   if (pending_tasks_.size() == 0)
 525     return;  // No pending tasks.
 526
 527   // Delete current task and repost if we have more task available.
 528   pending_tasks_.pop_front();
 529   if (pending_tasks_.size() != 0) {
 530     base::MessageLoop::current()->PostTask(
 531         FROM_HERE, base::Bind(&CloudPrintConnector::ProcessPendingTask, this));
 532   }
 533 }
 534
 535 void CloudPrintConnector::OnPrintersAvailable() {
 536   GURL printer_list_url = GetUrlForPrinterList(
 537       settings_.server_url(), settings_.proxy_id());
 538   StartGetRequest(printer_list_url,
 539                   kCloudPrintRegisterMaxRetryCount,
 540                   &CloudPrintConnector::HandlePrinterListResponse);
 541 }
 542
 543 void CloudPrintConnector::OnPrinterRegister(
 544     const printing::PrinterBasicInfo& info) {
 545   for (JobHandlerMap::iterator it = job_handler_map_.begin();
 546        it != job_handler_map_.end(); ++it) {
 547     if (IsSamePrinter(it->second->GetPrinterName(), info.printer_name)) {
 548       // Printer already registered, continue to the next task.
 549       ContinuePendingTaskProcessing();
 550       return;
 551     }
 552   }
 553
 554   // Asynchronously fetch the printer caps and defaults. The story will
 555   // continue in OnReceivePrinterCaps.
 556   print_system_->GetPrinterCapsAndDefaults(
 557       info.printer_name.c_str(),
 558       base::Bind(&CloudPrintConnector::OnReceivePrinterCaps,
 559                  base::Unretained(this)));
 560 }
 561
 562 void CloudPrintConnector::OnPrinterDelete(const std::string& printer_id) {
 563   // Remove corresponding printer job handler.
 564   JobHandlerMap::iterator it = job_handler_map_.find(printer_id);
 565   if (it != job_handler_map_.end()) {
 566     it->second->Shutdown();
 567     job_handler_map_.erase(it);
 568   }
 569
 570   // TODO(gene): We probably should not try indefinitely here. Just once or
 571   // twice should be enough.
 572   // Bug: http://code.google.com/p/chromium/issues/detail?id=101850
 573   GURL url = GetUrlForPrinterDelete(
 574       settings_.server_url(), printer_id, "printer_deleted");
 575   StartGetRequest(url,
 576                   kCloudPrintAPIMaxRetryCount,
 577                   &CloudPrintConnector::HandlePrinterDeleteResponse);
 578 }
 579
 580 void CloudPrintConnector::OnReceivePrinterCaps(
 581     bool succeeded,
 582     const std::string& printer_name,
 583     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
 584   if (!IsRunning())
 585     return;  // Orphant call.
 586   DCHECK(pending_tasks_.size() > 0 &&
 587          pending_tasks_.front().type == PENDING_PRINTER_REGISTER);
 588
 589   if (!succeeded) {
 590     LOG(ERROR) << "CP_CONNECTOR: Failed to get printer info"
 591                << ", printer name: " << printer_name;
 592     // This printer failed to register, notify the server of this failure.
 593     base::string16 printer_name_utf16 = base::UTF8ToUTF16(printer_name);
 594     std::string status_message = l10n_util::GetStringFUTF8(
 595         IDS_CLOUD_PRINT_REGISTER_PRINTER_FAILED,
 596         printer_name_utf16,
 597         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
 598     ReportUserMessage(kGetPrinterCapsFailedMessageId, status_message);
 599
 600     ContinuePendingTaskProcessing();  // Skip this printer registration.
 601     return;
 602   }
 603
 604   const printing::PrinterBasicInfo& info = pending_tasks_.front().printer_info;
 605   DCHECK(IsSamePrinter(info.printer_name, printer_name));
 606
 607   std::string mime_boundary;
 608   CreateMimeBoundaryForUpload(&mime_boundary);
 609   std::string post_data;
 610
 611   net::AddMultipartValueForUpload(kProxyIdValue,
 612       settings_.proxy_id(), mime_boundary, std::string(), &post_data);
 613   net::AddMultipartValueForUpload(kPrinterNameValue,
 614       info.printer_name, mime_boundary, std::string(), &post_data);
 615   net::AddMultipartValueForUpload(kPrinterDescValue,
 616       info.printer_description, mime_boundary, std::string(), &post_data);
 617   net::AddMultipartValueForUpload(kPrinterStatusValue,
 618       base::StringPrintf("%d", info.printer_status),
 619       mime_boundary, std::string(), &post_data);
 620   // Add local_settings with a current XMPP ping interval.
 621   net::AddMultipartValueForUpload(kPrinterLocalSettingsValue,
 622       base::StringPrintf(kCreateLocalSettingsXmppPingFormat,
 623           settings_.xmpp_ping_timeout_sec()),
 624       mime_boundary, std::string(), &post_data);
 625   post_data += GetPostDataForPrinterInfo(info, mime_boundary);
 626   if (caps_and_defaults.caps_mime_type == kContentTypeJSON) {
 627     net::AddMultipartValueForUpload(kUseCDD, "true", mime_boundary,
 628                                     std::string(), &post_data);
 629   }
 630   net::AddMultipartValueForUpload(kPrinterCapsValue,
 631       caps_and_defaults.printer_capabilities, mime_boundary,
 632       caps_and_defaults.caps_mime_type, &post_data);
 633   net::AddMultipartValueForUpload(kPrinterDefaultsValue,
 634       caps_and_defaults.printer_defaults, mime_boundary,
 635       caps_and_defaults.defaults_mime_type, &post_data);
 636   // Send a hash of the printer capabilities to the server. We will use this
 637   // later to check if the capabilities have changed
 638   net::AddMultipartValueForUpload(kPrinterCapsHashValue,
 639       base::MD5String(caps_and_defaults.printer_capabilities),
 640       mime_boundary, std::string(), &post_data);
 641   net::AddMultipartFinalDelimiterForUpload(mime_boundary, &post_data);
 642   std::string mime_type("multipart/form-data; boundary=");
 643   mime_type += mime_boundary;
 644
 645   GURL post_url = GetUrlForPrinterRegistration(settings_.server_url());
 646   StartPostRequest(CloudPrintURLFetcher::REQUEST_REGISTER, post_url,
 647                    kCloudPrintAPIMaxRetryCount, mime_type, post_data,
 648                    &CloudPrintConnector::HandleRegisterPrinterResponse);
 649 }
 650
 651 bool CloudPrintConnector::IsSamePrinter(const std::string& name1,
 652                                         const std::string& name2) const {
 653   return (0 == base::strcasecmp(name1.c_str(), name2.c_str()));
 654 }
 655
 656 }  // namespace cloud_print