Added confirmation for printer registration.

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>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "cloud_print/gcp20/prototype/command_line_reader.h"
 #include "cloud_print/gcp20/prototype/service_parameters.h"
+#include "cloud_print/gcp20/prototype/special_io.h"
 #include "net/base/net_util.h"
 #include "net/base/url_util.h"
 
-const char* kPrinterStatePath = "printer_state.json";
+const char kPrinterStatePath[] = "printer_state.json";
 
 namespace {
 
-const char* kServiceType = "_privet._tcp.local";
-const char* kServiceNamePrefix = "first_gcp20_device";
-const char* kServiceDomainName = "my-privet-device.local";
+const char kServiceType[] = "_privet._tcp.local";
+const char kServiceNamePrefix[] = "first_gcp20_device";
+const char kServiceDomainName[] = "my-privet-device.local";
 
-const char* kPrinterName = "Google GCP2.0 Prototype";
-const char* kPrinterDescription = "Printer emulator";
+const char kPrinterName[] = "Google GCP2.0 Prototype";
+const char kPrinterDescription[] = "Printer emulator";
 
-const char* kCdd =
+const char kUserConfirmationTitle[] = "Confirm registration: type 'y' if you "
+                                      "agree and any other to discard";
+const uint kUserConfirmationTimeout = 30;  // in seconds
+
+const char kCdd[] =
 "{\n"
 " 'version': '1.0',\n"
 "  'printer': {\n"
 "    'vendor_capability': [\n"
 "      {\n"
 "        'id': 'psk:MediaType',\n"
 "        'display_name': 'Media Type',\n"
 "        'type': 'SELECT',\n"
 "        'select_cap': {\n"
 "          'option': [\n"
@@ skipping 35 matching lines @@
       LOG(INFO) << net::IPAddressToString(iter->address);
       return iter->address;
     }
   }
 
   return net::IPAddressNumber();
 }
 
 }  // namespace
 
-Printer::RegistrationInfo::RegistrationInfo() : state(DEV_REG_UNREGISTERED) {
+Printer::RegistrationInfo::RegistrationInfo()
+    : state(DEV_REG_UNREGISTERED),
+      confirmation_state(CONFIRMATION_PENDING) {
 }
 
 Printer::RegistrationInfo::~RegistrationInfo() {
 }
 
 Printer::Printer() : http_server_(this) {
 }
 
 Printer::~Printer() {
   Stop();
@@ skipping 58 matching lines @@
   if (status != PrivetHttpServer::REG_ERROR_OK)
     return status;
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_UNREGISTERED)
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 
   reg_info_ = RegistrationInfo();
   reg_info_.user = user;
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_STARTED;
 
+  printf("%s\n", kUserConfirmationTitle);

[gene, 2013/07/18 09:56:46]

Why don't you just printf(kUserConfirmationTitle); here??
You can add '\n' to the const.

[maksymb, 2013/07/22 19:52:16]

Done.

+  base::Time valid_until = base::Time::Now() +
+      base::TimeDelta::FromSeconds(kUserConfirmationTimeout);
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&Printer::WaitUserConfirmation,
+                 base::Unretained(this), valid_until));
+
   requester_->StartRegistration(GenerateProxyId(), kPrinterName, user, kCdd);
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 bool Printer::CheckXPrivetTokenHeader(const std::string& token) const {
   return xtoken_.CheckValidXToken(token);
 }
 
 bool Printer::IsRegistered() const {
   return reg_info_.state == RegistrationInfo::DEV_REG_REGISTERED;
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationGetClaimToken(
     const std::string& user,
     std::string* token,
     std::string* claim_url) {
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK)
     return status;
 
-  // TODO(maksymb): Add user confirmation.
+  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;

[gene, 2013/07/18 09:56:46]

I think it should be different errors if registration not started vs token is
not ready 
Actually there should be different errors if user confirmation timeout or user
cancels it on the printer

[maksymb, 2013/07/22 19:52:16]

Added comments.

+
+  if (reg_info_.confirmation_state != RegistrationInfo::CONFIRMATION_CONFIRMED)
+    return ConfirmationToRegistrationError(reg_info_.confirmation_state);
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_REGISTRATION_STARTED)
     return PrivetHttpServer::REG_ERROR_DEVICE_BUSY;
 
-  if (reg_info_.state ==
-      RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY) {
-    *token = reg_info_.registration_token;
-    *claim_url = reg_info_.complete_invite_url;
-    return PrivetHttpServer::REG_ERROR_OK;
-  }
-
-  return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
+  *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;
   }
 
+  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;
 
   reg_info_ = RegistrationInfo();
+  requester_.reset(new CloudPrintRequester(
+      base::MessageLoop::current()->message_loop_proxy(),
+      this));  // Forget all old queries.
+
   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.";
 
   *description = reg_info_.error_description;
 }
 
@@ skipping 54 matching lines @@
       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;
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
+void Printer::WaitUserConfirmation(base::Time valid_until) {
+  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;
+      LOG(INFO) << "Registration confirmed by user.";
+    } else {
+      reg_info_.confirmation_state = RegistrationInfo::CONFIRMATION_DISCARDED;
+      LOG(INFO) << "Registration discarded by user.";
+    }
+    return;
+  }
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&Printer::WaitUserConfirmation, base::Unretained(this),
+                 valid_until),
+      base::TimeDelta::FromMilliseconds(100));
+}
+
 std::string Printer::GenerateProxyId() const {
   return "{" + base::GenerateGUID() +"}";
 }
 
 std::vector<std::string> Printer::CreateTxt() const {
   std::vector<std::string> txt;
   txt.push_back("txtvers=1");
   txt.push_back("ty=" + std::string(kPrinterName));
   txt.push_back("note=" + std::string(kPrinterDescription));
   txt.push_back("url=" + std::string(kCloudPrintUrl));
@@ skipping 78 matching lines @@
 
   reg_info_ = RegistrationInfo();
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTERED;
   reg_info_.user = user;
   reg_info_.device_id = device_id;
   reg_info_.refresh_token = refresh_token;
 
   return true;
 }
 
+PrivetHttpServer::RegistrationErrorStatus
+    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;
+    default:
+      NOTREACHED();
+      return PrivetHttpServer::REG_ERROR_OK;
+  }
+}
+