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"
 
+#if defined(OS_WIN)
+#include <conio.h>
+#else
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <termios.h>
+#include <unistd.h>
+#endif  // !defined(OS_WIN)
+#include <iostream>
 #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 "net/base/net_util.h"
 #include "net/base/url_util.h"
 
 const char* kPrinterStatePath = "printer_state.json";
 
 namespace {
 
 const char* kServiceType = "_privet._tcp.local";
 const char* kServiceNamePrefix = "first_gcp20_device";

[Vitaly Buka (NO REVIEWS), 2013/07/17 06:59:00]

Just noticed, please replace all such consts with 
const char kServiceType[] = "_privet._tcp.local";

[maksymb, 2013/07/17 18:24:50]

Done.

 const char* kServiceDomainName = "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 for otherwise.";
+const uint kUserConfirmationTimeout = 10;  // 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"
@@ skipping 34 matching lines @@
     if (iter->address.size() == expected_address_size &&
         (interface_name.empty() || interface_name == iter->name)) {
       LOG(INFO) << net::IPAddressToString(iter->address);
       return iter->address;
     }
   }
 
   return net::IPAddressNumber();
 }
 
+#if !defined(OS_WIN)

[maksymb, 2013/07/17 01:28:20]

I don't like to see all this stuff here, in this file. Is it better to move it
to separate file?

[Vitaly Buka (NO REVIEWS), 2013/07/17 06:59:00]

sure, you can put this in some file with _posix.cc suffix

[maksymb, 2013/07/17 18:24:50]

Done.

+
+// Method for disabling buffered IO.
+// |true| - disable, |false| - restore previous settings.
+void SetTemporaryTermiosSettings(bool temporary) {
+  static termios oldt, newt;
+
+  if (temporary) {
+    tcgetattr(STDIN_FILENO, &oldt);
+    newt = oldt;
+    newt.c_lflag &= ~ICANON;  // Disable buffered IO.
+    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+  } else {
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);  // Restore default settings.
+  }
+}
+
+// Analog from conio.h
+int kbhit() {
+  SetTemporaryTermiosSettings(true);
+
+  timeval tv;
+  fd_set rdfs;
+
+  tv.tv_sec = 0;
+  tv.tv_usec = 0;
+
+  FD_ZERO(&rdfs);
+  FD_SET(STDIN_FILENO, &rdfs);
+  select(STDIN_FILENO + 1, &rdfs, NULL, NULL, &tv);
+  SetTemporaryTermiosSettings(false);
+
+  return FD_ISSET(STDIN_FILENO, &rdfs);
+}
+
+// Analog from conio.h
+int getche() {
+  SetTemporaryTermiosSettings(true);
+  int c = getchar();
+  SetTemporaryTermiosSettings(false);
+  return c;
+}
+
+#endif  // !defined(OS_WIN)
+
 }  // 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;
 
+  std::cout << kUserConfirmationTitle << std::endl;
+  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;
+
+  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_DISCARTED;
+      LOG(INFO) << "Registration discarted 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_DISCARTED:
+      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;
+  }
+}
+