It2Me Confirmation Dialog

remoting/host/it2me/it2me_host.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 "remoting/host/it2me/it2me_host.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/host_status_logger.h"
+#include "remoting/host/it2me/it2me_confirmation_dialog.h"
 #include "remoting/host/it2me_desktop_environment.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/protocol/it2me_host_authenticator_factory.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/signaling/server_log_entry.h"
 
 namespace remoting {
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 const int kMaxLoginAttempts = 5;
 
 }  // namespace
 
 It2MeHost::It2MeHost(
     scoped_ptr<ChromotingHostContext> host_context,
     scoped_ptr<policy_hack::PolicyWatcher> policy_watcher,
+    scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid)
   : host_context_(host_context.Pass()),
     task_runner_(host_context_->ui_task_runner()),
     observer_(observer),
     xmpp_server_config_(xmpp_server_config),
     directory_bot_jid_(directory_bot_jid),
     state_(kDisconnected),
     failed_login_attempts_(0),
     policy_watcher_(policy_watcher.Pass()),
+    confirmation_dialog_factory_(confirmation_dialog_factory.Pass()),
     nat_traversal_enabled_(false),
     policy_received_(false) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void It2MeHost::Connect() {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::Connect, this));
     return;
   }
 
   desktop_environment_factory_.reset(new It2MeDesktopEnvironmentFactory(
       host_context_->network_task_runner(),
       host_context_->input_task_runner(),
       host_context_->ui_task_runner()));
 
   // Start monitoring configured policies.
   policy_watcher_->StartWatching(
       base::Bind(&It2MeHost::OnPolicyUpdate, this),
       base::Bind(&It2MeHost::OnPolicyError, this));
 
   // Switch to the network thread to start the actual connection.
   host_context_->network_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::ReadPolicyAndConnect, this));
+      FROM_HERE, base::Bind(&It2MeHost::ShowConfirmationPrompt, this));
 }
 
 void It2MeHost::Disconnect() {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::Disconnect, this));
     return;
   }
 
@@ skipping 34 matching lines @@
     DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::RequestNatPolicy, this));
     return;
   }
 
   if (policy_received_)
     UpdateNatPolicy(nat_traversal_enabled_);
 }
 
+void It2MeHost::ShowConfirmationPrompt() {
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+
+  SetState(kStarting);
+
+  scoped_ptr<It2MeConfirmationDialog> confirmation_dialog =
+      confirmation_dialog_factory_->Create();
+
+  // TODO(dcaiafa): Remove after dialog implementations for all platforms exist.
+  if (!confirmation_dialog) {
+    ReadPolicyAndConnect();
+    return;
+  }
+
+  confirmation_dialog_proxy_.reset(
+      new It2MeConfirmationDialogProxy(host_context_->ui_task_runner(),
+                                       confirmation_dialog.Pass()));
+
+  confirmation_dialog_proxy_->Show(
+      base::Bind(&It2MeHost::OnConfirmationResult, base::Unretained(this)));
+}
+
+void It2MeHost::OnConfirmationResult(It2MeConfirmationDialog::Result result) {
+  switch (result) {
+    case It2MeConfirmationDialog::Result::OK:
+      ReadPolicyAndConnect();
+      break;
+
+    case It2MeConfirmationDialog::Result::CANCEL:
+      Disconnect();
+      break;
+
+    default:
+      NOTREACHED();
+      return;
+  }
+}
+
 void It2MeHost::ReadPolicyAndConnect() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
-
-  SetState(kStarting);
+  DCHECK_EQ(kStarting, state_);
 
   // Only proceed to FinishConnect() if at least one policy update has been
   // received.
   if (policy_received_) {
     FinishConnect();
   } else {
     // Otherwise, create the policy watcher, and thunk the connect.
     pending_connect_ =
         base::Bind(&It2MeHost::FinishConnect, this);
   }
@@ skipping 81 matching lines @@
   host_->Start(xmpp_server_config_.username);
 
   SetState(kRequestedAccessCode);
   return;
 }
 
 void It2MeHost::ShutdownOnNetworkThread() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(state_ == kDisconnecting || state_ == kDisconnected);
 
+  confirmation_dialog_proxy_.reset();
+
   if (state_ == kDisconnecting) {
     host_event_logger_.reset();
     host_->RemoveStatusObserver(this);
     host_.reset();
 
     register_request_.reset();
     host_status_logger_.reset();
     signal_strategy_.reset();
     SetState(kDisconnected);
   }
@@ skipping 237 matching lines @@
   DCHECK(policy_service);
   DCHECK(!policy_service_) << "|policy_service| can only be set once.";
   policy_service_ = policy_service;
 }
 
 scoped_refptr<It2MeHost> It2MeHostFactory::CreateIt2MeHost(
     scoped_ptr<ChromotingHostContext> context,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid) {
+  scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
+      new It2MeConfirmationDialogFactory());
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher =
       policy_hack::PolicyWatcher::Create(policy_service_,
                                          context->network_task_runner());
-  return new It2MeHost(context.Pass(), policy_watcher.Pass(), observer,
-                       xmpp_server_config, directory_bot_jid);
+  return new It2MeHost(context.Pass(), policy_watcher.Pass(),
+                       confirmation_dialog_factory.Pass(),
+                       observer, xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting