[Blimp Net] Add EngineAuthHandler.

blimp/net/engine_authentication_handler.cc

Index: blimp/net/engine_authentication_handler.cc
diff --git a/blimp/net/engine_authentication_handler.cc b/blimp/net/engine_authentication_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a9527eb8fb9eccbd4b062124814ea3feb472b181
--- /dev/null
+++ b/blimp/net/engine_authentication_handler.cc
@@ -0,0 +1,124 @@
+// Copyright 2015 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 "blimp/net/engine_authentication_handler.h"
+
+#include "base/callback_helpers.h"
+#include "base/logging.h"
+#include "base/timer/timer.h"
+#include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/net/blimp_connection.h"
+#include "blimp/net/blimp_message_processor.h"
+#include "blimp/net/blimp_transport.h"
+#include "blimp/net/connection_error_observer.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
+
+namespace blimp {
+
+namespace {
+// Expect authentication to be done in 10 seconds.
+const double kAuthTimeoutDurationInSeconds = 10;
+
+// Authenticates one connection. It deletes itself when
+//   * the connection is authenticated and passed to |connection_handler|.
+//   * the connection gets into error state.
+//   * timeout on waiting for auth message.
+class Authenticator : public ConnectionErrorObserver,
+                      public BlimpMessageProcessor {
+ public:
+  explicit Authenticator(scoped_ptr<BlimpConnection> connection,
+                         base::WeakPtr<ConnectionHandler> connection_handler);
+  ~Authenticator() override;
+
+ private:
+  // Processes authentication result and delete this object.
+  void OnConnectionAuthenticated(bool authenticated);
+
+  // Invoked on timeout while waiting for auth message.
+  void OnAuthenticationTimeout();
+
+  // ConnectionErrorObserver implementation.
+  void OnConnectionError(int error) override;
+
+  // BlimpMessageProcessor implementation.
+  void ProcessMessage(scoped_ptr<BlimpMessage> message,
+                      const net::CompletionCallback& callback) override;
+
+  // The connection to be authenticated.
+  scoped_ptr<BlimpConnection> connection_;
+
+  // Handler for authenticated connections.
+  base::WeakPtr<ConnectionHandler> connection_handler_;

[Kevin M, 2015/12/04 19:12:05]

This isn't used anymore; remove it and all references to it

[haibinlu, 2015/12/07 21:54:50]

It is used to take a connection when it is authenticated.

+
+  // A timer to fail authentication on timeout.
+  base::OneShotTimer timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(Authenticator);
+};
+
+Authenticator::Authenticator(
+    scoped_ptr<BlimpConnection> connection,
+    base::WeakPtr<ConnectionHandler> connection_handler)
+    : connection_(std::move(connection)),
+      connection_handler_(connection_handler) {
+  connection_->SetConnectionErrorObserver(this);
+  connection_->SetIncomingMessageProcessor(this);
+  timer_.Start(FROM_HERE,

[Kevin M, 2015/12/04 19:12:05]

Constructors shouldn't be responsible for doing actual work - put this in a
Start() method.

[haibinlu, 2015/12/07 21:54:50]

Per wez's previous comment, Start method is removed.

+               base::TimeDelta::FromSecondsD(kAuthTimeoutDurationInSeconds),
+               this, &Authenticator::OnAuthenticationTimeout);
+}
+
+Authenticator::~Authenticator() {}
+
+void Authenticator::OnConnectionAuthenticated(bool authenticated) {
+  timer_.Stop();
+  connection_->SetIncomingMessageProcessor(nullptr);
+  connection_->SetConnectionErrorObserver(nullptr);
+
+  if (authenticated) {
+    connection_handler_->HandleConnection(std::move(connection_));
+  }
+
+  delete this;
+}
+
+void Authenticator::OnAuthenticationTimeout() {
+  DVLOG(1) << "Connection authentication timeout";
+  OnConnectionAuthenticated(false);
+}
+
+void Authenticator::OnConnectionError(int error) {
+  DVLOG(1) << "Connection error before authenticated";
+  OnConnectionAuthenticated(false);
+}
+
+void Authenticator::ProcessMessage(scoped_ptr<BlimpMessage> message,
+                                   const net::CompletionCallback& callback) {
+  if (message->type() == BlimpMessage::PROTOCOL_CONTROL) {
+    // TODO(haibinlu): check client token.
+    OnConnectionAuthenticated(true);
+  } else {
+    OnConnectionAuthenticated(false);
+  }
+
+  callback.Run(net::OK);
+}
+
+}  // namespace
+
+EngineAuthenticationHandler::EngineAuthenticationHandler(
+    ConnectionHandler* connection_handler)
+    : connection_handler_weak_factory_(connection_handler) {}
+
+EngineAuthenticationHandler::~EngineAuthenticationHandler() {}
+
+void EngineAuthenticationHandler::HandleConnection(
+    scoped_ptr<BlimpConnection> connection) {
+  // Authenticator manages its own lifetime.
+  new Authenticator(std::move(connection),
+                    connection_handler_weak_factory_.GetWeakPtr());
+}
+
+}  // namespace blimp