Adding a new authenticator which can be used to validate the remote user

remoting/protocol/validating_authenticator.cc

Index: remoting/protocol/validating_authenticator.cc
diff --git a/remoting/protocol/validating_authenticator.cc b/remoting/protocol/validating_authenticator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d3da78d12427b741dfdc5359bbb02aebd98ee93c
--- /dev/null
+++ b/remoting/protocol/validating_authenticator.cc
@@ -0,0 +1,141 @@
+// Copyright 2016 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/protocol/validating_authenticator.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "remoting/protocol/authenticator.h"
+#include "remoting/protocol/channel_authenticator.h"
+#include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
+
+namespace remoting {
+namespace protocol {
+
+ValidatingAuthenticator::ValidatingAuthenticator(
+    const std::string& remote_jid,
+    const ValidationCallback& validation_callback,
+    std::unique_ptr<Authenticator> current_authenticator)
+    : remote_jid_(remote_jid),
+      validation_callback_(validation_callback),
+      current_authenticator_(std::move(current_authenticator)),
+      weak_factory_(this) {
+  DCHECK(!remote_jid_.empty());
+  DCHECK(!validation_callback_.is_null());
+  DCHECK(current_authenticator_);
+}
+
+ValidatingAuthenticator::~ValidatingAuthenticator() {}
+
+Authenticator::State ValidatingAuthenticator::state() const {
+  return state_;
+}
+
+bool ValidatingAuthenticator::started() const {
+  return current_authenticator_->started();
+}
+
+Authenticator::RejectionReason ValidatingAuthenticator::rejection_reason()
+    const {
+  return rejection_reason_;
+}
+
+const std::string& ValidatingAuthenticator::GetAuthKey() const {
+  return current_authenticator_->GetAuthKey();
+}
+
+std::unique_ptr<ChannelAuthenticator>
+ValidatingAuthenticator::CreateChannelAuthenticator() const {
+  return current_authenticator_->CreateChannelAuthenticator();
+}
+
+void ValidatingAuthenticator::ProcessMessage(
+    const buzz::XmlElement* message,
+    const base::Closure& resume_callback) {
+  DCHECK_EQ(state_, WAITING_MESSAGE);
+  state_ = PROCESSING_MESSAGE;
+
+  if (first_message_received_) {
+    current_authenticator_->ProcessMessage(
+        message, base::Bind(&ValidatingAuthenticator::UpdateState,
+                            weak_factory_.GetWeakPtr(), resume_callback));
+  } else {
+    first_message_received_ = true;
+    validation_callback_.Run(
+        remote_jid_, base::Bind(&ValidatingAuthenticator::OnValidateComplete,
+                                weak_factory_.GetWeakPtr(),
+                                base::Owned(new buzz::XmlElement(*message)),
+                                resume_callback));
+  }
+}
+
+std::unique_ptr<buzz::XmlElement> ValidatingAuthenticator::GetNextMessage() {
+  std::unique_ptr<buzz::XmlElement> result(
+      current_authenticator_->GetNextMessage());
+  state_ = current_authenticator_->state();
+  DCHECK(state_ == ACCEPTED || state_ == WAITING_MESSAGE);
+
+  return result;
+}
+
+void ValidatingAuthenticator::OnValidateComplete(
+    const buzz::XmlElement* message,
+    const base::Closure& resume_callback,
+    Result validation_result) {
+  if (validation_result == Result::SUCCESS) {
+    current_authenticator_->ProcessMessage(
+        message, base::Bind(&ValidatingAuthenticator::UpdateState,
+                            weak_factory_.GetWeakPtr(), resume_callback));
+    return;
+  }
+
+  // |validation_result| represents a rejected state so map the result to a
+  // rejection reason and call the callback to let the caller know the result.
+  state_ = Authenticator::REJECTED;
+
+  switch (validation_result) {
+    case Result::ERROR_INVALID_CREDENTIALS:
+      rejection_reason_ = Authenticator::INVALID_CREDENTIALS;
+      break;
+
+    case Result::ERROR_INVALID_ACCOUNT:
+      rejection_reason_ = Authenticator::INVALID_ACCOUNT;
+      break;
+
+    case Result::ERROR_REJECTED_BY_USER:
+      rejection_reason_ = Authenticator::REJECTED_BY_USER;
+      break;
+
+    default:

[Sergey Ulanov, 2016/08/31 23:41:24]

It's best to avoid default case for enum switch statments. Otherwise compiler
will not help when someone adds another value in the enum and doesn't update
this switch() statement. replace this with Result::SUCCESS?

+      // Log an error and fail to prevent logging a misleading error value.
+      CHECK(false) << "Unknown validation result value: "

[Sergey Ulanov, 2016/08/31 23:41:24]

I think NOTREACHED() would be appropriate here - the connection is REJECTED
anyway. See
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...

+                   << static_cast<unsigned int>(validation_result);
+  }
+
+  resume_callback.Run();
+}
+
+void ValidatingAuthenticator::UpdateState(
+    const base::Closure& resume_callback) {
+  DCHECK_EQ(state_, PROCESSING_MESSAGE);
+
+  // Update our current state before running |resume_callback|.
+  state_ = current_authenticator_->state();
+  if (state_ == REJECTED) {
+    rejection_reason_ = current_authenticator_->rejection_reason();
+  }
+
+  resume_callback.Run();
+}
+
+}  // namespace protocol
+}  // namespace remoting