GCP2.0 Device: Instant AccessToken update on AuthFailed.

cloud_print/gcp20/prototype/printer.cc

 // Copyright 2013 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 "cloud_print/gcp20/prototype/printer.h"
 
 #include <stdio.h>
 #include <string>
 #include <vector>
 
@@ skipping 20 matching lines @@
 
 const char kServiceType[] = "_privet._tcp.local";
 const char kServiceNamePrefixDefault[] = "first_gcp20_device";
 const char kServiceDomainNameDefault[] = "my-privet-device.local";
 
 const char kPrinterName[] = "Google GCP2.0 Prototype";
 const char kPrinterDescription[] = "Printer emulator";
 
 const char kUserConfirmationTitle[] = "Confirm registration: type 'y' if you "
                                       "agree and any other to discard\n";
-const int64 kUserConfirmationTimeout = 30;  // in seconds
-
-const uint32 kReconnectTimeout = 5;  // in seconds
+const int kUserConfirmationTimeout = 30;  // in seconds
+const int kRegistrationTimeout = 60;  // in seconds
+const int kReconnectTimeout = 5;  // in seconds
 
 const double kTimeToNextAccessTokenUpdate = 0.8;  // relatively to living time.
 
 const char kCdd[] =
 "{\n"
 " 'version': '1.0',\n"
 "  'printer': {\n"
 "    'vendor_capability': [\n"
 "      {\n"
 "        'id': 'psk:MediaType',\n"
@@ skipping 121 matching lines @@
 
 void Printer::Stop() {
   dns_server_.Shutdown();
   http_server_.Shutdown();
   requester_.reset();
   print_job_handler_.reset();
   xmpp_listener_.reset();
 }
 
 void Printer::OnAuthError() {
-  access_token_update_ = base::Time::Now();
-  ChangeState(OFFLINE);
-  // TODO(maksymb): Implement *instant* updating of access_token.
+  access_token_update_ = base::Time::UnixEpoch();
+  ReconnectIn(base::TimeDelta::FromSeconds(0));
 }
 
 std::string Printer::GetAccessToken() {
   return access_token_;
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationStart(
     const std::string& user) {
+  CheckRegistrationExpiration();
+  RegistrationInfo::ConfirmationState conf_state = reg_info_.confirmation_state;
+  if (user != reg_info_.user)
+    if (conf_state == RegistrationInfo::CONFIRMATION_TIMEOUT ||
+        conf_state == RegistrationInfo::CONFIRMATION_DISCARDED) {
+      reg_info_ = RegistrationInfo();
+    }
+
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK)
     return status;
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_UNREGISTERED)
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 
+  UpdateRegistrationExpiration();
+
   reg_info_ = RegistrationInfo();
   reg_info_.user = user;
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_STARTED;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch("disable-confirmation")) {
     reg_info_.confirmation_state = RegistrationInfo::CONFIRMATION_CONFIRMED;
     LOG(INFO) << "Registration confirmed by default.";
   } else {
     printf("%s", kUserConfirmationTitle);
     base::Time valid_until = base::Time::Now() +
@@ skipping 20 matching lines @@
   if (reg_info_.state != RegistrationInfo::DEV_REG_REGISTRATION_STARTED &&
       reg_info_.state !=
           RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY)
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 
   // If |action=getClaimToken| is valid in this state (was checked above) then
   // check confirmation status.
   if (reg_info_.confirmation_state != RegistrationInfo::CONFIRMATION_CONFIRMED)
     return ConfirmationToRegistrationError(reg_info_.confirmation_state);
 
+  UpdateRegistrationExpiration();
+
   // If reply wasn't received yet, reply with |device_busy| error.
   if (reg_info_.state == RegistrationInfo::DEV_REG_REGISTRATION_STARTED)
     return PrivetHttpServer::REG_ERROR_DEVICE_BUSY;
 
   DCHECK_EQ(reg_info_.state,
             RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY);
   DCHECK_EQ(reg_info_.confirmation_state,
             RegistrationInfo::CONFIRMATION_CONFIRMED);
 
   *token = reg_info_.registration_token;
   *claim_url = reg_info_.complete_invite_url;
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationComplete(
     const std::string& user,
     std::string* device_id) {
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK)
     return status;
 
   if (reg_info_.state !=
       RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY) {
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
   }
 
+  UpdateRegistrationExpiration();
+
   if (reg_info_.confirmation_state != RegistrationInfo::CONFIRMATION_CONFIRMED)
     return ConfirmationToRegistrationError(reg_info_.confirmation_state);
 
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_COMPLETING;
   requester_->CompleteRegistration();
   *device_id = reg_info_.device_id;
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationCancel(
     const std::string& user) {
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK &&
       status != PrivetHttpServer::REG_ERROR_SERVER_ERROR) {
     return status;
   }
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_UNREGISTERED)
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 
+  InvalidateRegistrationExpiration();
+
   reg_info_ = RegistrationInfo();
   requester_.reset(new CloudPrintRequester(GetTaskRunner(), this));
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 void Printer::GetRegistrationServerError(std::string* description) {
-  DCHECK_EQ(reg_info_.state, RegistrationInfo::DEV_REG_REGISTRATION_ERROR) <<
-      "Method shouldn't be called when not needed.";
+  DCHECK_EQ(reg_info_.state, RegistrationInfo::DEV_REG_REGISTRATION_ERROR)
+      << "Method shouldn't be called when not needed.";
 
   *description = reg_info_.error_description;
 }
 
 void Printer::CreateInfo(PrivetHttpServer::DeviceInfo* info) {
+  CheckRegistrationExpiration();
+
   // TODO(maksymb): Replace "text" with constants.
 
   *info = PrivetHttpServer::DeviceInfo();
   info->version = "1.0";
   info->name = kPrinterName;
   info->description = kPrinterDescription;
   info->url = kCloudPrintUrl;
   info->id = reg_info_.device_id;
   info->device_state = "idle";
   info->connection_state = ConnectionStateToString(connection_state_);
   info->manufacturer = "Google";
   info->model = "Prototype";
   info->serial_number = "2.3.5.7.13.17.19.31.61.89.107.127.521.607.1279.2203";
   info->firmware = "3.7.31.127.8191.131071.524287.2147483647";
   info->uptime = static_cast<int>((base::Time::Now() - starttime_).InSeconds());
 
   info->x_privet_token = xtoken_.GenerateXToken();
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_UNREGISTERED)
     info->api.push_back("/privet/register");
 
   info->type.push_back("printer");
 }
 
-bool Printer::IsRegistered() const {
+bool Printer::IsRegistered() {
+  CheckRegistrationExpiration();
   return reg_info_.state == RegistrationInfo::DEV_REG_REGISTERED;
 }
 
 bool Printer::CheckXPrivetTokenHeader(const std::string& token) const {
   return xtoken_.CheckValidXToken(token);
 }
 
 void Printer::OnRegistrationStartResponseParsed(
     const std::string& registration_token,
     const std::string& complete_invite_url,
     const std::string& device_id) {
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY;
   reg_info_.device_id = device_id;
   reg_info_.registration_token = registration_token;
   reg_info_.complete_invite_url = complete_invite_url;
 }
 
-void Printer::OnGetAuthCodeResponseParsed(const std::string& refresh_token,
-                                          const std::string& access_token,
-                                          int access_token_expires_in_seconds) {
+void Printer::OnRegistrationFinished(const std::string& refresh_token,
+                                     const std::string& access_token,
+                                     int access_token_expires_in_seconds) {
+  InvalidateRegistrationExpiration();
+
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTERED;
   reg_info_.refresh_token = refresh_token;
   RememberAccessToken(access_token, access_token_expires_in_seconds);
   TryConnect();
 }
 
 void Printer::OnAccesstokenReceviced(const std::string& access_token,
                                      int expires_in_seconds) {
   VLOG(3) << "Function: " << __FUNCTION__;
   RememberAccessToken(access_token, expires_in_seconds);
@@ skipping 12 matching lines @@
 }
 
 void Printer::OnXmppJidReceived(const std::string& xmpp_jid) {
   reg_info_.xmpp_jid = xmpp_jid;
 }
 
 void Printer::OnRegistrationError(const std::string& description) {
   LOG(ERROR) << "server_error: " << description;
 
   // TODO(maksymb): Implement waiting after error and timeout of registration.
-  reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_ERROR;
-  reg_info_.error_description = description;
+  SetRegistrationError(description);
 }
 
 void Printer::OnNetworkError() {
   VLOG(3) << "Function: " << __FUNCTION__;
   ChangeState(OFFLINE);
 }
 
 void Printer::OnServerError(const std::string& description) {
   VLOG(3) << "Function: " << __FUNCTION__;
   LOG(ERROR) << "Server error: " << description;
@@ skipping 139 matching lines @@
   using base::Time;
   using base::TimeDelta;
   access_token_ = access_token;
   int64 time_to_update = static_cast<int64>(expires_in_seconds *
                                             kTimeToNextAccessTokenUpdate);
   access_token_update_ = Time::Now() + TimeDelta::FromSeconds(time_to_update);
   VLOG(1) << "Current access_token: " << access_token;
   SaveToFile();
 }
 
+void Printer::SetRegistrationError(const std::string& description) {
+  DCHECK(!IsRegistered());
+  reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_ERROR;
+  reg_info_.error_description = description;
+}
+
 PrivetHttpServer::RegistrationErrorStatus Printer::CheckCommonRegErrors(
-    const std::string& user) const {
+    const std::string& user) {
+  CheckRegistrationExpiration();
   DCHECK(!IsRegistered());
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_UNREGISTERED &&
       user != reg_info_.user) {
     return PrivetHttpServer::REG_ERROR_DEVICE_BUSY;
   }
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_REGISTRATION_ERROR)
     return PrivetHttpServer::REG_ERROR_SERVER_ERROR;
 
+  DCHECK(connection_state_ == ONLINE);
+
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 void Printer::WaitUserConfirmation(base::Time valid_until) {
+  // TODO(maksymb): Move to separate class.
+
   if (base::Time::Now() > valid_until) {
     reg_info_.confirmation_state = RegistrationInfo::CONFIRMATION_TIMEOUT;
     LOG(INFO) << "Confirmation timeout reached.";
     return;
   }
 
   if (_kbhit()) {
     int c = _getche();
     if (c == 'y' || c == 'Y') {
       reg_info_.confirmation_state = RegistrationInfo::CONFIRMATION_CONFIRMED;
@@ skipping 21 matching lines @@
   txt.push_back("ty=" + std::string(kPrinterName));
   txt.push_back("note=" + std::string(kPrinterDescription));
   txt.push_back("url=" + std::string(kCloudPrintUrl));
   txt.push_back("type=printer");
   txt.push_back("id=" + reg_info_.device_id);
   txt.push_back("cs=" + ConnectionStateToString(connection_state_));
 
   return txt;
 }
 
-void Printer::SaveToFile() const {
+void Printer::SaveToFile() {
   base::FilePath file_path;
   file_path = file_path.AppendASCII(
       command_line_reader::ReadStatePath(kPrinterStatePathDefault));
 
   base::DictionaryValue json;
   // TODO(maksymb): Get rid of in-place constants.
   if (IsRegistered()) {
     json.SetBoolean("registered", true);
     json.SetString("user", reg_info_.user);
     json.SetString("device_id", reg_info_.device_id);
@@ skipping 103 matching lines @@
 void Printer::PostOnIdle() {
   VLOG(3) << "Function: " << __FUNCTION__;
   DCHECK(!on_idle_posted_) << "Only one instance can be posted.";
   on_idle_posted_ = true;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&Printer::OnIdle, AsWeakPtr()));
 }
 
+void Printer::CheckRegistrationExpiration() {
+  if (!registration_expiration_.is_null() &&
+      registration_expiration_ < base::Time::Now()) {
+    reg_info_ = RegistrationInfo();
+    InvalidateRegistrationExpiration();
+    if (connection_state_ != ONLINE)
+      TryConnect();
+  }
+}
+
+void Printer::UpdateRegistrationExpiration() {
+  registration_expiration_ =
+      base::Time::Now() + base::TimeDelta::FromSeconds(kRegistrationTimeout);
+}
+
+void Printer::InvalidateRegistrationExpiration() {
+  registration_expiration_ = base::Time();
+}
+
 PrivetHttpServer::RegistrationErrorStatus
-    Printer::ConfirmationToRegistrationError(
-        RegistrationInfo::ConfirmationState state) {
+Printer::ConfirmationToRegistrationError(
+    RegistrationInfo::ConfirmationState state) {
   switch (state) {
     case RegistrationInfo::CONFIRMATION_PENDING:
       return PrivetHttpServer::REG_ERROR_PENDING_USER_ACTION;
     case RegistrationInfo::CONFIRMATION_DISCARDED:
       return PrivetHttpServer::REG_ERROR_USER_CANCEL;
     case RegistrationInfo::CONFIRMATION_CONFIRMED:
       NOTREACHED();
       return PrivetHttpServer::REG_ERROR_OK;
     case RegistrationInfo::CONFIRMATION_TIMEOUT:
       return PrivetHttpServer::REG_ERROR_CONFIRMATION_TIMEOUT;
@@ skipping 13 matching lines @@
       return "connecting";
     case NOT_CONFIGURED:
       return "not-configured";
 
     default:
       NOTREACHED();
       return "";
   }
 }
 
+void Printer::ReconnectIn(const base::TimeDelta& delay) {
+  if (!IsRegistered()) {
+    SetRegistrationError("Cannot access server during registration process");

[gene, 2013/08/08 02:01:55]

I am not sure I understand in what cases this error is returned.

[maksymb, 2013/08/08 18:35:46]

Once something bad happened during registration, this method will be called and
we will block registration process.
In this case user can start registration again with
/privet/register?action=start

+    return;
+  }
+
+  requester_.reset();
+  xmpp_listener_.reset();
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&Printer::TryConnect, AsWeakPtr()),
+      delay);
+}
+
 bool Printer::ChangeState(ConnectionState new_state) {
   if (connection_state_ == new_state)
     return false;
 
   connection_state_ = new_state;
   LOG(INFO) << base::StringPrintf(
       "Printer is now %s (%s)",
       ConnectionStateToString(connection_state_).c_str(),
       IsRegistered() ? "registered" : "unregistered");
 
   dns_server_.UpdateMetadata(CreateTxt());
 
-  switch (connection_state_) {
-    case CONNECTING:
-      break;
-
-    case ONLINE:
-      break;
-
-    case OFFLINE:
-      requester_.reset();
-      xmpp_listener_.reset();
-      base::MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&Printer::TryConnect, AsWeakPtr()),
-          base::TimeDelta::FromSeconds(kReconnectTimeout));
-
-    case NOT_CONFIGURED:
-      break;
-
-    default:
-      NOTREACHED();
-  }
+  if (connection_state_ == OFFLINE)
+    ReconnectIn(base::TimeDelta::FromSeconds(kReconnectTimeout));
 
   return true;
 }