Adding the message definitions for the remote_security_key STDIO communication classes.

remoting/host/security_key/security_key_message.cc

Index: remoting/host/security_key/security_key_message.cc
diff --git a/remoting/host/security_key/security_key_message.cc b/remoting/host/security_key/security_key_message.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d0c6d54a033b33c8585cf08edc5aea7817457d13
--- /dev/null
+++ b/remoting/host/security_key/security_key_message.cc
@@ -0,0 +1,49 @@
+// 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/host/security_key/security_key_message.h"
+
+namespace {
+
+// Limit remote security key messages to 256KB.
+const uint32_t kMaxSecurityKeyMessageByteCount = 256 * 1024;
+
+const int kRemoteSecurityKeyMessageControlCodeByteCount = sizeof(uint8_t);

[Sergey Ulanov, 2016/03/24 21:51:17]

1 instead sizeof(uint8_t) please

[joedow, 2016/03/28 19:44:26]

Done.

+
+}  // namespace
+
+namespace remoting {
+
+const int SecurityKeyMessage::kHeaderSizeBytes = sizeof(uint32_t);

[Sergey Ulanov, 2016/03/24 21:51:17]

nit: replace sizeof(uint32_t) with 4.

[joedow, 2016/03/28 19:44:26]

Acknowledged.

+
+SecurityKeyMessage::SecurityKeyMessage() {}
+
+SecurityKeyMessage::~SecurityKeyMessage() {}
+
+bool SecurityKeyMessage::IsValidMessageSize(uint32_t message_size) {
+  return message_size > 0 && message_size <= kMaxSecurityKeyMessageByteCount;
+}
+
+bool SecurityKeyMessage::ParseMessage(const std::string& message_data) {
+  if (!IsValidMessageSize(message_data.size())) {
+    return false;
+  }
+
+  // The first char of the message is the message type.
+  type_ = static_cast<RemoteSecurityKeyMessageType>(message_data[0]);
+  if (type_ == RemoteSecurityKeyMessageType::kUnitialized) {

[Sergey Ulanov, 2016/03/24 21:51:17]

Do we also need to validate that it's in accepted range. E.g. should this accept
type_=33?

[joedow, 2016/03/28 19:44:26]

I thought about adding validation in but I don't think it is worth it as there
is already a form of validation in the handler class (i.e. unknown messagea are
rejected)..  When we add messages or new error conditions, we need to update the
enum and our validate function and I'd prefer this data type be simple and keep
the validation in the handling code.

[Sergey Ulanov, 2016/03/29 01:05:51]

I think we want to validate the value before the static_cast<>. static_cast<>
behavior is unspecified when casting int type to enum. See
http://stackoverflow.com/questions/18195312/what-happens-if-you-static-cast-i...

This means that the compiler is allowed to crash. It's also allowed to truncate
the higher bits, which means that the value may become valid after conversion. 

Alternatively you can change type of |type_| to int and assume that it's
supposed to be validated elsewhere.

+    return false;
+  }
+
+  payload_.clear();
+  if (message_data.size() > kRemoteSecurityKeyMessageControlCodeByteCount) {
+    payload_.reserve(message_data.size() - 1);
+    std::string::const_iterator it = message_data.begin();
+    payload_.append(++it, message_data.end());

[Sergey Ulanov, 2016/03/24 21:51:17]

You don't really gain anything by calling reserve() if append() is called only
once. Also std::string uses random access iterator, so you could use "begin() +
1" here. But I think this would be more readable using substr(), i.e:
 payload_ = message_data.substr(1);

[joedow, 2016/03/28 19:44:26]

Done.

+  }
+
+  return true;
+}
+
+}  // namespace remoting