Home | History | Annotate | Download | only in prototype 
      1 // Copyright 2013 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 "cloud_print/gcp20/prototype/cloud_print_xmpp_listener.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/rand_util.h"
     11 #include "base/single_thread_task_runner.h"
     12 #include "cloud_print/gcp20/prototype/cloud_print_url_request_context_getter.h"
     13 #include "jingle/notifier/base/notifier_options.h"
     14 #include "jingle/notifier/listener/push_client.h"
     15 
     16 namespace {
     17 
     18 const int kUrgentPingInterval = 60;  // in seconds
     19 const int kPingTimeout = 30;  // in seconds
     20 const double kRandomDelayPercentage = 0.2;
     21 
     22 const char kCloudPrintPushNotificationsSource[] = "cloudprint.google.com";
     23 
     24 // Splits message into two parts (e.g. '<device_id>/delete' will be splitted
     25 // into '<device_id>' and '/delete').
     26 void TokenizeXmppMessage(const std::string& message, std::string* device_id,
     27                          std::string* path) {
     28   std::string::size_type pos = message.find('/');
     29   if (pos != std::string::npos) {
     30     *device_id = message.substr(0, pos);
     31     *path = message.substr(pos);
     32   } else {
     33     *device_id = message;
     34     path->clear();
     35   }
     36 }
     37 
     38 }  // namespace
     39 
     40 CloudPrintXmppListener::CloudPrintXmppListener(
     41     const std::string& robot_email,
     42     int standard_ping_interval,
     43     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     44     Delegate* delegate)
     45     : robot_email_(robot_email),
     46       standard_ping_interval_(standard_ping_interval),
     47       ping_timeouts_posted_(0),
     48       ping_responses_pending_(0),
     49       ping_scheduled_(false),
     50       context_getter_(new CloudPrintURLRequestContextGetter(task_runner)),
     51       delegate_(delegate) {
     52 }
     53 
     54 CloudPrintXmppListener::~CloudPrintXmppListener() {
     55   if (push_client_) {
     56     push_client_->RemoveObserver(this);
     57     push_client_.reset();
     58   }
     59 }
     60 
     61 void CloudPrintXmppListener::Connect(const std::string& access_token) {
     62   access_token_ = access_token;
     63   ping_responses_pending_ = 0;
     64   ping_scheduled_ = false;
     65 
     66   notifier::NotifierOptions options;
     67   options.request_context_getter = context_getter_;
     68   options.auth_mechanism = "X-OAUTH2";
     69   options.try_ssltcp_first = true;
     70   push_client_ = notifier::PushClient::CreateDefault(options);
     71 
     72   notifier::Subscription subscription;
     73   subscription.channel = kCloudPrintPushNotificationsSource;
     74   subscription.from = kCloudPrintPushNotificationsSource;
     75 
     76   notifier::SubscriptionList list;
     77   list.push_back(subscription);
     78 
     79   push_client_->UpdateSubscriptions(list);
     80   push_client_->AddObserver(this);
     81   push_client_->UpdateCredentials(robot_email_, access_token_);
     82 }
     83 
     84 void CloudPrintXmppListener::set_ping_interval(int interval) {
     85   standard_ping_interval_ = interval;
     86 }
     87 
     88 void CloudPrintXmppListener::OnNotificationsEnabled() {
     89   delegate_->OnXmppConnected();
     90   SchedulePing();
     91 }
     92 
     93 void CloudPrintXmppListener::OnNotificationsDisabled(
     94     notifier::NotificationsDisabledReason reason) {
     95   switch (reason) {
     96     case notifier::NOTIFICATION_CREDENTIALS_REJECTED:
     97       delegate_->OnXmppAuthError();
     98       break;
     99     case notifier::TRANSIENT_NOTIFICATION_ERROR:
    100       Disconnect();
    101       break;
    102     default:
    103       NOTREACHED() << "XMPP failed with unexpected reason code: " << reason;
    104   }
    105 }
    106 
    107 void CloudPrintXmppListener::OnIncomingNotification(
    108     const notifier::Notification& notification) {
    109   std::string device_id;
    110   std::string path;
    111   TokenizeXmppMessage(notification.data, &device_id, &path);
    112 
    113   if (path.empty() || path == "/") {
    114     delegate_->OnXmppNewPrintJob(device_id);
    115   } else if (path == "/update_settings") {
    116     delegate_->OnXmppNewLocalSettings(device_id);
    117   } else if (path == "/delete") {
    118     delegate_->OnXmppDeleteNotification(device_id);
    119   } else {
    120     LOG(ERROR) << "Cannot parse XMPP notification: " << notification.data;
    121   }
    122 }
    123 
    124 void CloudPrintXmppListener::OnPingResponse() {
    125   ping_responses_pending_ = 0;
    126   SchedulePing();
    127 }
    128 
    129 void CloudPrintXmppListener::Disconnect() {
    130   push_client_.reset();
    131   delegate_->OnXmppNetworkError();
    132 }
    133 
    134 void CloudPrintXmppListener::SchedulePing() {
    135   if (ping_scheduled_)
    136     return;
    137 
    138   DCHECK_LE(kPingTimeout, kUrgentPingInterval);
    139   int delay = (ping_responses_pending_ > 0)
    140       ? kUrgentPingInterval - kPingTimeout
    141       : standard_ping_interval_;
    142 
    143   delay += base::RandInt(0, delay*kRandomDelayPercentage);
    144 
    145   base::MessageLoop::current()->PostDelayedTask(
    146       FROM_HERE,
    147       base::Bind(&CloudPrintXmppListener::SendPing, AsWeakPtr()),
    148       base::TimeDelta::FromSeconds(delay));
    149 
    150   ping_scheduled_ = true;
    151 }
    152 
    153 void CloudPrintXmppListener::SendPing() {
    154   ping_scheduled_ = false;
    155 
    156   DCHECK(push_client_);
    157   push_client_->SendPing();
    158   ++ping_responses_pending_;
    159 
    160   base::MessageLoop::current()->PostDelayedTask(
    161         FROM_HERE,
    162         base::Bind(&CloudPrintXmppListener::OnPingTimeoutReached, AsWeakPtr()),
    163         base::TimeDelta::FromSeconds(kPingTimeout));
    164   ++ping_timeouts_posted_;
    165 }
    166 
    167 void CloudPrintXmppListener::OnPingTimeoutReached() {
    168   DCHECK_GT(ping_timeouts_posted_, 0);
    169   --ping_timeouts_posted_;
    170   if (ping_timeouts_posted_ > 0)
    171     return;  // Fake (old) timeout.
    172 
    173   switch (ping_responses_pending_) {
    174     case 0:
    175       break;
    176     case 1:
    177       SchedulePing();
    178       break;
    179     case 2:
    180       Disconnect();
    181       break;
    182     default:
    183       NOTREACHED();
    184   }
    185 }
    186 
    187