Use Chromium BUILD to approximate Blimp protocol version, and check it.

blimp/net/engine_authentication_handler.cc

 // 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 <string>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/timer/timer.h"
+#include "blimp/common/create_blimp_message.h"
 #include "blimp/common/logging.h"
 #include "blimp/common/proto/blimp_message.pb.h"
+#include "blimp/common/version_info.h"
 #include "blimp/net/blimp_connection.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_transport.h"
 #include "blimp/net/common.h"
 #include "blimp/net/connection_error_observer.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 
 namespace blimp {
 
@@ skipping 80 matching lines @@
 }
 
 void Authenticator::OnConnectionError(int error) {
   DVLOG(1) << "Connection error before authenticated "
            << net::ErrorToString(error);
   OnConnectionAuthenticated(false);
 }
 
 void Authenticator::ProcessMessage(std::unique_ptr<BlimpMessage> message,
                                    const net::CompletionCallback& callback) {
-  if (message->type() == BlimpMessage::PROTOCOL_CONTROL &&
-      message->protocol_control().type() ==
-          ProtocolControlMessage::START_CONNECTION) {
-    bool token_match =
-        client_token_ ==
-        message->protocol_control().start_connection().client_token();
-    DVLOG(1) << "Authentication challenge received: "
-             << message->protocol_control().start_connection().client_token()
-             << ", and token "
-             << (token_match ? " matches" : " does not match");
-    OnConnectionAuthenticated(token_match);
-  } else {
-    DVLOG(1) << "Expected START_CONNECTION message, got " << *message
-             << " instead.";
+  base::ScopedClosureRunner run_callback(base::Bind(callback, net::OK));
+
+  if ((message->type() != BlimpMessage::PROTOCOL_CONTROL) ||
+      (message->protocol_control().type() !=
+       ProtocolControlMessage::START_CONNECTION)) {
+    DVLOG(1) << "Expected PROTOCOL_CONTROL->START_CONNECTION, got " << *message;
     OnConnectionAuthenticated(false);
+    return;
   }
 
-  callback.Run(net::OK);
+  const StartConnectionMessage& start_connection =
+      message->protocol_control().start_connection();
+
+  // Verify that the protocol version is supported.
+  if (start_connection.protocol_version() != GetProtocolVersion()) {
+    DVLOG(1) << "Protocol version mismatch: "

[Kevin M, 2016/04/22 21:12:54]

Could be good to VLOG(), since this error might be a source of developer
confusion down the line?

+             << start_connection.protocol_version() << " vs "
+             << GetProtocolVersion();
+
+    // Inform the client of the mismatch before disconnecting it, so it can
+    // show the user an appropriate error.
+    connection_->GetOutgoingMessageProcessor()->ProcessMessage(
+        CreateEndConnectionMessage(EndConnectionMessage::PROTOCOL_MISMATCH),
+        net::CompletionCallback());
+
+    OnConnectionAuthenticated(false);
+    return;
+  }
+
+  // Verify that the authentication token matches.
+  bool token_match = client_token_ == start_connection.client_token();
+  DVLOG(1) << "Authentication challenge received: "
+           << start_connection.client_token() << ", and token "
+           << (token_match ? " matches" : " does not match");
+  OnConnectionAuthenticated(token_match);
 }
 
 }  // namespace
 
 EngineAuthenticationHandler::EngineAuthenticationHandler(
     ConnectionHandler* connection_handler,
     const std::string& client_token)
     : connection_handler_weak_factory_(connection_handler),
       client_token_(client_token) {
   DCHECK(!client_token_.empty());
 }
 
 EngineAuthenticationHandler::~EngineAuthenticationHandler() {}
 
 void EngineAuthenticationHandler::HandleConnection(
     std::unique_ptr<BlimpConnection> connection) {
   // Authenticator manages its own lifetime.
   new Authenticator(std::move(connection),
                     connection_handler_weak_factory_.GetWeakPtr(),
                     client_token_);
 }
 
 }  // namespace blimp