Home | History | Annotate | Download | only in cloud_print 
      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_proxy_backend.h"
      6 
      7 #include <map>
      8 #include <vector>
      9 
     10 #include "base/bind.h"
     11 #include "base/command_line.h"
     12 #include "base/compiler_specific.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/rand_util.h"
     15 #include "base/values.h"
     16 #include "chrome/common/chrome_switches.h"
     17 #include "chrome/common/cloud_print/cloud_print_constants.h"
     18 #include "chrome/service/cloud_print/cloud_print_auth.h"
     19 #include "chrome/service/cloud_print/cloud_print_connector.h"
     20 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
     21 #include "chrome/service/cloud_print/cloud_print_token_store.h"
     22 #include "chrome/service/cloud_print/connector_settings.h"
     23 #include "chrome/service/net/service_url_request_context.h"
     24 #include "chrome/service/service_process.h"
     25 #include "google_apis/gaia/gaia_oauth_client.h"
     26 #include "google_apis/gaia/gaia_urls.h"
     27 #include "grit/generated_resources.h"
     28 #include "jingle/notifier/base/notifier_options.h"
     29 #include "jingle/notifier/listener/push_client.h"
     30 #include "jingle/notifier/listener/push_client_observer.h"
     31 #include "ui/base/l10n/l10n_util.h"
     32 #include "url/gurl.h"
     33 
     34 namespace cloud_print {
     35 
     36 // The real guts of CloudPrintProxyBackend, to keep the public client API clean.
     37 class CloudPrintProxyBackend::Core
     38     : public base::RefCountedThreadSafe<CloudPrintProxyBackend::Core>,
     39       public CloudPrintAuth::Client,
     40       public CloudPrintConnector::Client,
     41       public notifier::PushClientObserver {
     42  public:
     43   // It is OK for print_server_url to be empty. In this case system should
     44   // use system default (local) print server.
     45   Core(CloudPrintProxyBackend* backend,
     46        const ConnectorSettings& settings,
     47        const gaia::OAuthClientInfo& oauth_client_info,
     48        bool enable_job_poll);
     49 
     50   // Note:
     51   //
     52   // The Do* methods are the various entry points from CloudPrintProxyBackend
     53   // It calls us on a dedicated thread to actually perform synchronous
     54   // (and potentially blocking) operations.
     55   void DoInitializeWithToken(const std::string& cloud_print_token);
     56   void DoInitializeWithRobotToken(const std::string& robot_oauth_refresh_token,
     57                                   const std::string& robot_email);
     58   void DoInitializeWithRobotAuthCode(const std::string& robot_oauth_auth_code,
     59                                      const std::string& robot_email);
     60 
     61   // Called on the CloudPrintProxyBackend core_thread_ to perform
     62   // shutdown.
     63   void DoShutdown();
     64   void DoRegisterSelectedPrinters(
     65       const printing::PrinterList& printer_list);
     66   void DoUnregisterPrinters();
     67 
     68   // CloudPrintAuth::Client implementation.
     69   virtual void OnAuthenticationComplete(
     70       const std::string& access_token,
     71       const std::string& robot_oauth_refresh_token,
     72       const std::string& robot_email,
     73       const std::string& user_email) OVERRIDE;
     74   virtual void OnInvalidCredentials() OVERRIDE;
     75 
     76   // CloudPrintConnector::Client implementation.
     77   virtual void OnAuthFailed() OVERRIDE;
     78   virtual void OnXmppPingUpdated(int ping_timeout) OVERRIDE;
     79 
     80   // notifier::PushClientObserver implementation.
     81   virtual void OnNotificationsEnabled() OVERRIDE;
     82   virtual void OnNotificationsDisabled(
     83       notifier::NotificationsDisabledReason reason) OVERRIDE;
     84   virtual void OnIncomingNotification(
     85       const notifier::Notification& notification) OVERRIDE;
     86   virtual void OnPingResponse() OVERRIDE;
     87 
     88  private:
     89   friend class base::RefCountedThreadSafe<Core>;
     90 
     91   virtual ~Core() {}
     92 
     93   void CreateAuthAndConnector();
     94   void DestroyAuthAndConnector();
     95 
     96   // NotifyXXX is how the Core communicates with the frontend across
     97   // threads.
     98   void NotifyPrinterListAvailable(
     99       const printing::PrinterList& printer_list);
    100   void NotifyAuthenticated(
    101     const std::string& robot_oauth_refresh_token,
    102     const std::string& robot_email,
    103     const std::string& user_email);
    104   void NotifyAuthenticationFailed();
    105   void NotifyPrintSystemUnavailable();
    106   void NotifyUnregisterPrinters(const std::string& auth_token,
    107                                 const std::list<std::string>& printer_ids);
    108   void NotifyXmppPingUpdated(int ping_timeout);
    109 
    110   // Init XMPP channel
    111   void InitNotifications(const std::string& robot_email,
    112                          const std::string& access_token);
    113 
    114   void HandlePrinterNotification(const std::string& notification);
    115   void PollForJobs();
    116   // Schedules a task to poll for jobs. Does nothing if a task is already
    117   // scheduled.
    118   void ScheduleJobPoll();
    119   void PingXmppServer();
    120   void ScheduleXmppPing();
    121   void CheckXmppPingStatus();
    122 
    123   CloudPrintTokenStore* GetTokenStore();
    124 
    125   // Our parent CloudPrintProxyBackend
    126   CloudPrintProxyBackend* backend_;
    127 
    128   // Cloud Print authenticator.
    129   scoped_refptr<CloudPrintAuth> auth_;
    130 
    131   // Cloud Print connector.
    132   scoped_refptr<CloudPrintConnector> connector_;
    133 
    134   // OAuth client info.
    135   gaia::OAuthClientInfo oauth_client_info_;
    136   // Notification (xmpp) handler.
    137   scoped_ptr<notifier::PushClient> push_client_;
    138   // Indicates whether XMPP notifications are currently enabled.
    139   bool notifications_enabled_;
    140   // The time when notifications were enabled. Valid only when
    141   // notifications_enabled_ is true.
    142   base::TimeTicks notifications_enabled_since_;
    143   // Indicates whether a task to poll for jobs has been scheduled.
    144   bool job_poll_scheduled_;
    145   // Indicates whether we should poll for jobs when we lose XMPP connection.
    146   bool enable_job_poll_;
    147   // Indicates whether a task to ping xmpp server has been scheduled.
    148   bool xmpp_ping_scheduled_;
    149   // Number of XMPP pings pending reply from the server.
    150   int pending_xmpp_pings_;
    151   // Connector settings.
    152   ConnectorSettings settings_;
    153   std::string robot_email_;
    154   scoped_ptr<CloudPrintTokenStore> token_store_;
    155 
    156   DISALLOW_COPY_AND_ASSIGN(Core);
    157 };
    158 
    159 CloudPrintProxyBackend::CloudPrintProxyBackend(
    160     CloudPrintProxyFrontend* frontend,
    161     const ConnectorSettings& settings,
    162     const gaia::OAuthClientInfo& oauth_client_info,
    163     bool enable_job_poll)
    164     : core_thread_("Chrome_CloudPrintProxyCoreThread"),
    165       frontend_loop_(base::MessageLoop::current()),
    166       frontend_(frontend) {
    167   DCHECK(frontend_);
    168   core_ = new Core(this, settings, oauth_client_info, enable_job_poll);
    169 }
    170 
    171 CloudPrintProxyBackend::~CloudPrintProxyBackend() { DCHECK(!core_.get()); }
    172 
    173 bool CloudPrintProxyBackend::InitializeWithToken(
    174     const std::string& cloud_print_token) {
    175   if (!core_thread_.Start())
    176     return false;
    177   core_thread_.message_loop()->PostTask(
    178       FROM_HERE,
    179       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithToken,
    180                  core_.get(), cloud_print_token));
    181   return true;
    182 }
    183 
    184 bool CloudPrintProxyBackend::InitializeWithRobotToken(
    185     const std::string& robot_oauth_refresh_token,
    186     const std::string& robot_email) {
    187   if (!core_thread_.Start())
    188     return false;
    189   core_thread_.message_loop()->PostTask(
    190       FROM_HERE,
    191       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotToken,
    192                  core_.get(), robot_oauth_refresh_token, robot_email));
    193   return true;
    194 }
    195 
    196 bool CloudPrintProxyBackend::InitializeWithRobotAuthCode(
    197     const std::string& robot_oauth_auth_code,
    198     const std::string& robot_email) {
    199   if (!core_thread_.Start())
    200     return false;
    201   core_thread_.message_loop()->PostTask(
    202       FROM_HERE,
    203       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode,
    204                  core_.get(), robot_oauth_auth_code, robot_email));
    205   return true;
    206 }
    207 
    208 void CloudPrintProxyBackend::Shutdown() {
    209   core_thread_.message_loop()->PostTask(
    210       FROM_HERE,
    211       base::Bind(&CloudPrintProxyBackend::Core::DoShutdown, core_.get()));
    212   core_thread_.Stop();
    213   core_ = NULL;  // Releases reference to core_.
    214 }
    215 
    216 void CloudPrintProxyBackend::UnregisterPrinters() {
    217   core_thread_.message_loop()->PostTask(
    218       FROM_HERE,
    219       base::Bind(&CloudPrintProxyBackend::Core::DoUnregisterPrinters,
    220                  core_.get()));
    221 }
    222 
    223 CloudPrintProxyBackend::Core::Core(
    224     CloudPrintProxyBackend* backend,
    225     const ConnectorSettings& settings,
    226     const gaia::OAuthClientInfo& oauth_client_info,
    227     bool enable_job_poll)
    228       : backend_(backend),
    229         oauth_client_info_(oauth_client_info),
    230         notifications_enabled_(false),
    231         job_poll_scheduled_(false),
    232         enable_job_poll_(enable_job_poll),
    233         xmpp_ping_scheduled_(false),
    234         pending_xmpp_pings_(0) {
    235   settings_.CopyFrom(settings);
    236 }
    237 
    238 void CloudPrintProxyBackend::Core::CreateAuthAndConnector() {
    239   if (!auth_.get()) {
    240     auth_ = new CloudPrintAuth(this, settings_.server_url(), oauth_client_info_,
    241                                settings_.proxy_id());
    242   }
    243 
    244   if (!connector_.get()) {
    245     connector_ = new CloudPrintConnector(this, settings_);
    246   }
    247 }
    248 
    249 void CloudPrintProxyBackend::Core::DestroyAuthAndConnector() {
    250   auth_ = NULL;
    251   connector_ = NULL;
    252 }
    253 
    254 void CloudPrintProxyBackend::Core::DoInitializeWithToken(
    255     const std::string& cloud_print_token) {
    256   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    257   CreateAuthAndConnector();
    258   auth_->AuthenticateWithToken(cloud_print_token);
    259 }
    260 
    261 void CloudPrintProxyBackend::Core::DoInitializeWithRobotToken(
    262     const std::string& robot_oauth_refresh_token,
    263     const std::string& robot_email) {
    264   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    265   CreateAuthAndConnector();
    266   auth_->AuthenticateWithRobotToken(robot_oauth_refresh_token, robot_email);
    267 }
    268 
    269 void CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode(
    270     const std::string& robot_oauth_auth_code,
    271     const std::string& robot_email) {
    272   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    273   CreateAuthAndConnector();
    274   auth_->AuthenticateWithRobotAuthCode(robot_oauth_auth_code, robot_email);
    275 }
    276 
    277 void CloudPrintProxyBackend::Core::OnAuthenticationComplete(
    278     const std::string& access_token,
    279     const std::string& robot_oauth_refresh_token,
    280     const std::string& robot_email,
    281     const std::string& user_email) {
    282   CloudPrintTokenStore* token_store  = GetTokenStore();
    283   bool first_time = token_store->token().empty();
    284   token_store->SetToken(access_token);
    285   robot_email_ = robot_email;
    286   // Let the frontend know that we have authenticated.
    287   backend_->frontend_loop_->PostTask(
    288       FROM_HERE,
    289       base::Bind(&Core::NotifyAuthenticated, this, robot_oauth_refresh_token,
    290                  robot_email, user_email));
    291   if (first_time) {
    292     InitNotifications(robot_email, access_token);
    293   } else {
    294     // If we are refreshing a token, update the XMPP token too.
    295     DCHECK(push_client_.get());
    296     push_client_->UpdateCredentials(robot_email, access_token);
    297   }
    298   // Start cloud print connector if needed.
    299   if (!connector_->IsRunning()) {
    300     if (!connector_->Start()) {
    301       // Let the frontend know that we do not have a print system.
    302       backend_->frontend_loop_->PostTask(
    303           FROM_HERE, base::Bind(&Core::NotifyPrintSystemUnavailable, this));
    304     }
    305   }
    306 }
    307 
    308 void CloudPrintProxyBackend::Core::OnInvalidCredentials() {
    309   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    310   VLOG(1) << "CP_CONNECTOR: Auth Error";
    311   backend_->frontend_loop_->PostTask(
    312       FROM_HERE, base::Bind(&Core::NotifyAuthenticationFailed, this));
    313 }
    314 
    315 void CloudPrintProxyBackend::Core::OnAuthFailed() {
    316   VLOG(1) << "CP_CONNECTOR: Authentication failed in connector.";
    317   // Let's stop connecter and refresh token. We'll restart connecter once
    318   // new token available.
    319   if (connector_->IsRunning())
    320     connector_->Stop();
    321 
    322   // Refresh Auth token.
    323   auth_->RefreshAccessToken();
    324 }
    325 
    326 void CloudPrintProxyBackend::Core::OnXmppPingUpdated(int ping_timeout) {
    327   settings_.SetXmppPingTimeoutSec(ping_timeout);
    328   backend_->frontend_loop_->PostTask(
    329       FROM_HERE,
    330       base::Bind(&Core::NotifyXmppPingUpdated, this, ping_timeout));
    331 }
    332 
    333 void CloudPrintProxyBackend::Core::InitNotifications(
    334     const std::string& robot_email,
    335     const std::string& access_token) {
    336   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    337 
    338   pending_xmpp_pings_ = 0;
    339   notifier::NotifierOptions notifier_options;
    340   notifier_options.request_context_getter =
    341       g_service_process->GetServiceURLRequestContextGetter();
    342   notifier_options.auth_mechanism = "X-OAUTH2";
    343   notifier_options.try_ssltcp_first = true;
    344   push_client_ = notifier::PushClient::CreateDefault(notifier_options);
    345   push_client_->AddObserver(this);
    346   notifier::Subscription subscription;
    347   subscription.channel = kCloudPrintPushNotificationsSource;
    348   subscription.from = kCloudPrintPushNotificationsSource;
    349   push_client_->UpdateSubscriptions(
    350       notifier::SubscriptionList(1, subscription));
    351   push_client_->UpdateCredentials(robot_email, access_token);
    352 }
    353 
    354 void CloudPrintProxyBackend::Core::DoShutdown() {
    355   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    356   VLOG(1) << "CP_CONNECTOR: Shutdown connector, id: " << settings_.proxy_id();
    357 
    358   if (connector_->IsRunning())
    359     connector_->Stop();
    360 
    361   // Important to delete the PushClient on this thread.
    362   if (push_client_.get()) {
    363     push_client_->RemoveObserver(this);
    364   }
    365   push_client_.reset();
    366   notifications_enabled_ = false;
    367   notifications_enabled_since_ = base::TimeTicks();
    368   token_store_.reset();
    369 
    370   DestroyAuthAndConnector();
    371 }
    372 
    373 void CloudPrintProxyBackend::Core::DoUnregisterPrinters() {
    374   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    375 
    376   std::string access_token = GetTokenStore()->token();
    377 
    378   std::list<std::string> printer_ids;
    379   connector_->GetPrinterIds(&printer_ids);
    380 
    381   backend_->frontend_loop_->PostTask(
    382       FROM_HERE,
    383       base::Bind(&Core::NotifyUnregisterPrinters,
    384                  this, access_token, printer_ids));
    385 }
    386 
    387 void CloudPrintProxyBackend::Core::HandlePrinterNotification(
    388     const std::string& notification) {
    389   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    390 
    391   size_t pos = notification.rfind(kNotificationUpdateSettings);
    392   if (pos == std::string::npos) {
    393     VLOG(1) << "CP_CONNECTOR: Handle printer notification, id: "
    394             << notification;
    395     connector_->CheckForJobs(kJobFetchReasonNotified, notification);
    396   } else {
    397     DCHECK(pos == notification.length() - strlen(kNotificationUpdateSettings));
    398     std::string printer_id = notification.substr(0, pos);
    399     VLOG(1) << "CP_CONNECTOR: Update printer settings, id: " << printer_id;
    400     connector_->UpdatePrinterSettings(printer_id);
    401   }
    402 }
    403 
    404 void CloudPrintProxyBackend::Core::PollForJobs() {
    405   VLOG(1) << "CP_CONNECTOR: Polling for jobs.";
    406   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    407   // Check all printers for jobs.
    408   connector_->CheckForJobs(kJobFetchReasonPoll, std::string());
    409 
    410   job_poll_scheduled_ = false;
    411   // If we don't have notifications and job polling is enabled, poll again
    412   // after a while.
    413   if (!notifications_enabled_ && enable_job_poll_)
    414     ScheduleJobPoll();
    415 }
    416 
    417 void CloudPrintProxyBackend::Core::ScheduleJobPoll() {
    418   if (!job_poll_scheduled_) {
    419     base::TimeDelta interval = base::TimeDelta::FromSeconds(
    420         base::RandInt(kMinJobPollIntervalSecs, kMaxJobPollIntervalSecs));
    421     base::MessageLoop::current()->PostDelayedTask(
    422         FROM_HERE,
    423         base::Bind(&CloudPrintProxyBackend::Core::PollForJobs, this),
    424         interval);
    425     job_poll_scheduled_ = true;
    426   }
    427 }
    428 
    429 void CloudPrintProxyBackend::Core::PingXmppServer() {
    430   xmpp_ping_scheduled_ = false;
    431 
    432   if (!push_client_.get())
    433     return;
    434 
    435   push_client_->SendPing();
    436 
    437   pending_xmpp_pings_++;
    438   if (pending_xmpp_pings_ >= kMaxFailedXmppPings) {
    439     // Check ping status when we close to the limit.
    440     base::MessageLoop::current()->PostDelayedTask(
    441         FROM_HERE,
    442         base::Bind(&CloudPrintProxyBackend::Core::CheckXmppPingStatus, this),
    443         base::TimeDelta::FromSeconds(kXmppPingCheckIntervalSecs));
    444   }
    445 
    446   // Schedule next ping if needed.
    447   if (notifications_enabled_)
    448     ScheduleXmppPing();
    449 }
    450 
    451 void CloudPrintProxyBackend::Core::ScheduleXmppPing() {
    452   // settings_.xmpp_ping_enabled() is obsolete, we are now control
    453   // XMPP pings from Cloud Print server.
    454   if (!xmpp_ping_scheduled_) {
    455     base::TimeDelta interval = base::TimeDelta::FromSeconds(
    456       base::RandInt(settings_.xmpp_ping_timeout_sec() * 0.9,
    457                     settings_.xmpp_ping_timeout_sec() * 1.1));
    458     base::MessageLoop::current()->PostDelayedTask(
    459         FROM_HERE,
    460         base::Bind(&CloudPrintProxyBackend::Core::PingXmppServer, this),
    461         interval);
    462     xmpp_ping_scheduled_ = true;
    463   }
    464 }
    465 
    466 void CloudPrintProxyBackend::Core::CheckXmppPingStatus() {
    467   if (pending_xmpp_pings_ >= kMaxFailedXmppPings) {
    468     UMA_HISTOGRAM_COUNTS_100("CloudPrint.XmppPingTry", 99);  // Max on fail.
    469     // Reconnect to XMPP.
    470     pending_xmpp_pings_ = 0;
    471     push_client_.reset();
    472     InitNotifications(robot_email_, GetTokenStore()->token());
    473   }
    474 }
    475 
    476 CloudPrintTokenStore* CloudPrintProxyBackend::Core::GetTokenStore() {
    477   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    478   if (!token_store_.get())
    479     token_store_.reset(new CloudPrintTokenStore);
    480   return token_store_.get();
    481 }
    482 
    483 void CloudPrintProxyBackend::Core::NotifyAuthenticated(
    484     const std::string& robot_oauth_refresh_token,
    485     const std::string& robot_email,
    486     const std::string& user_email) {
    487   DCHECK(base::MessageLoop::current() == backend_->frontend_loop_);
    488   backend_->frontend_
    489       ->OnAuthenticated(robot_oauth_refresh_token, robot_email, user_email);
    490 }
    491 
    492 void CloudPrintProxyBackend::Core::NotifyAuthenticationFailed() {
    493   DCHECK(base::MessageLoop::current() == backend_->frontend_loop_);
    494   backend_->frontend_->OnAuthenticationFailed();
    495 }
    496 
    497 void CloudPrintProxyBackend::Core::NotifyPrintSystemUnavailable() {
    498   DCHECK(base::MessageLoop::current() == backend_->frontend_loop_);
    499   backend_->frontend_->OnPrintSystemUnavailable();
    500 }
    501 
    502 void CloudPrintProxyBackend::Core::NotifyUnregisterPrinters(
    503     const std::string& auth_token,
    504     const std::list<std::string>& printer_ids) {
    505   DCHECK(base::MessageLoop::current() == backend_->frontend_loop_);
    506   backend_->frontend_->OnUnregisterPrinters(auth_token, printer_ids);
    507 }
    508 
    509 void CloudPrintProxyBackend::Core::NotifyXmppPingUpdated(int ping_timeout) {
    510   DCHECK(base::MessageLoop::current() == backend_->frontend_loop_);
    511   backend_->frontend_->OnXmppPingUpdated(ping_timeout);
    512 }
    513 
    514 void CloudPrintProxyBackend::Core::OnNotificationsEnabled() {
    515   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    516   notifications_enabled_ = true;
    517   notifications_enabled_since_ = base::TimeTicks::Now();
    518   VLOG(1) << "Notifications for connector " << settings_.proxy_id()
    519           << " were enabled at "
    520           << notifications_enabled_since_.ToInternalValue();
    521   // Notifications just got re-enabled. In this case we want to schedule
    522   // a poll once for jobs we might have missed when we were dark.
    523   // Note that ScheduleJobPoll will not schedule again if a job poll task is
    524   // already scheduled.
    525   ScheduleJobPoll();
    526 
    527   // Schedule periodic ping for XMPP notification channel.
    528   ScheduleXmppPing();
    529 }
    530 
    531 void CloudPrintProxyBackend::Core::OnNotificationsDisabled(
    532     notifier::NotificationsDisabledReason reason) {
    533   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    534   notifications_enabled_ = false;
    535   LOG(ERROR) << "Notifications for connector " << settings_.proxy_id()
    536              << " disabled.";
    537   notifications_enabled_since_ = base::TimeTicks();
    538   // We just lost notifications. This this case we want to schedule a
    539   // job poll if enable_job_poll_ is true.
    540   if (enable_job_poll_)
    541     ScheduleJobPoll();
    542 }
    543 
    544 
    545 void CloudPrintProxyBackend::Core::OnIncomingNotification(
    546     const notifier::Notification& notification) {
    547   // Since we got some notification from the server,
    548   // reset pending ping counter to 0.
    549   pending_xmpp_pings_ = 0;
    550 
    551   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
    552   VLOG(1) << "CP_CONNECTOR: Incoming notification.";
    553   if (0 == base::strcasecmp(kCloudPrintPushNotificationsSource,
    554                             notification.channel.c_str()))
    555     HandlePrinterNotification(notification.data);
    556 }
    557 
    558 void CloudPrintProxyBackend::Core::OnPingResponse() {
    559   UMA_HISTOGRAM_COUNTS_100("CloudPrint.XmppPingTry", pending_xmpp_pings_);
    560   pending_xmpp_pings_ = 0;
    561   VLOG(1) << "CP_CONNECTOR: Ping response received.";
    562 }
    563 
    564 }  // namespace cloud_print
    565