Create dedicated class for handling wire message formatting and parsing.

extensions/browser/api/cast_channel/cast_socket_unittest.cc

Index: extensions/browser/api/cast_channel/cast_socket_unittest.cc
diff --git a/extensions/browser/api/cast_channel/cast_socket_unittest.cc b/extensions/browser/api/cast_channel/cast_socket_unittest.cc
index 4090426cf06045bf7ced4b02e8601872e591678a..36a1ab23fc5bab47accb50b2851e3beea40a1ad1 100644
--- a/extensions/browser/api/cast_channel/cast_socket_unittest.cc
+++ b/extensions/browser/api/cast_channel/cast_socket_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "extensions/browser/api/cast_channel/cast_socket.h"
 
+#include <vector>
+
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -198,7 +200,7 @@ class TestCastSocket : public CastSocket {
 
   // Returns the size of the body (in bytes) of the given serialized message.
   static size_t ComputeBodySize(const std::string& msg) {
-    return msg.length() - CastSocket::MessageHeader::header_size();
+    return msg.length() - PacketFramer::MessageHeader::header_size();
   }
 
   virtual ~TestCastSocket() {
@@ -252,8 +254,9 @@ class TestCastSocket : public CastSocket {
   void AddReadResultForMessage(net::IoMode mode, const std::string& msg) {
     size_t body_size = ComputeBodySize(msg);
     const char* data = msg.c_str();
-    AddReadResult(mode, data, MessageHeader::header_size());
-    AddReadResult(mode, data + MessageHeader::header_size(), body_size);
+    AddReadResult(mode, data, PacketFramer::MessageHeader::header_size());
+    AddReadResult(
+        mode, data + PacketFramer::MessageHeader::header_size(), body_size);
   }
   void AddReadResultForMessage(net::IoMode mode,
                                const std::string& msg,
@@ -357,14 +360,17 @@ class CastSocketTest : public testing::Test {
                           &test_messages_[i]);
       ASSERT_TRUE(MessageInfoToCastMessage(
           test_messages_[i], &test_protos_[i]));
-      ASSERT_TRUE(CastSocket::Serialize(test_protos_[i], &test_proto_strs_[i]));
+      ASSERT_TRUE(
+          PacketFramer::Serialize(test_protos_[i], &test_proto_strs_[i]));
     }
   }
 
   virtual void TearDown() OVERRIDE {
-    EXPECT_CALL(handler_, OnCloseComplete(net::OK));
-    socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
-                              base::Unretained(&handler_)));
+    if (socket_.get()) {
+      EXPECT_CALL(handler_, OnCloseComplete(net::OK));
+      socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
+                                base::Unretained(&handler_)));
+    }
   }
 
   // The caller can specify non-standard namespaces by setting "auth_namespace"
@@ -374,7 +380,7 @@ class CastSocketTest : public testing::Test {
     // Create a test auth request.
     CastMessage request;
     CreateAuthChallengeMessage(&request);
-    ASSERT_TRUE(CastSocket::Serialize(request, &auth_request_));
+    ASSERT_TRUE(PacketFramer::Serialize(request, &auth_request_));
 
     // Create a test auth reply.
     MessageInfo reply;
@@ -382,7 +388,7 @@ class CastSocketTest : public testing::Test {
         auth_namespace, "sender-0", "receiver-0", "abcd", &reply);
     CastMessage reply_msg;
     ASSERT_TRUE(MessageInfoToCastMessage(reply, &reply_msg));
-    ASSERT_TRUE(CastSocket::Serialize(reply_msg, &auth_reply_));
+    ASSERT_TRUE(PacketFramer::Serialize(reply_msg, &auth_reply_));
   }
 
   void CreateCastSocket() {
@@ -945,7 +951,7 @@ TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
   SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
-  size_t size = CastSocket::MessageHeader::max_message_size() + 1;
+  size_t size = PacketFramer::MessageHeader::max_message_size() + 1;
   test_messages_[0].data.reset(
       new base::StringValue(std::string(size, 'a')));
   socket_->SendMessage(test_messages_[0],
@@ -1163,8 +1169,8 @@ TEST_F(CastSocketTest, TestReadErrorSync) {
 TEST_F(CastSocketTest, TestReadHeaderParseError) {
   CreateCastSocket();
   SetupAuthMessage();
-  uint32 body_size = base::HostToNet32(
-      CastSocket::MessageHeader::max_message_size() + 1);
+  uint32 body_size =
+      base::HostToNet32(PacketFramer::MessageHeader::max_message_size() + 1);
   // TODO(munjal): Add a method to cast_message_util.h to serialize messages

[mark a. foltz, 2014/08/26 20:37:03]

Can we use the MessageFramer to resolve this TODO?

[Kevin M, 2014/08/27 01:14:04]

I don't think it would work in this case, since MessageFramer::Serialize has
protections against illegal/oversized messages (which is an error condition
tested in this case.)

   char header[sizeof(body_size)];
   memcpy(&header, &body_size, arraysize(header));
@@ -1201,6 +1207,38 @@ TEST_F(CastSocketTest, TestReadBodyParseError) {
             socket_->error_state());
 }
 
+TEST_F(CastSocketTest, TestFramerBitsAndPieces) {

[mark a. foltz, 2014/08/26 20:37:03]

TestMessageFramerCompleteMessage?

Also would like to see tests that exercise error scenarios for Serialize() and
Ingest().

+  scoped_refptr<net::GrowableIOBuffer> buffer(new net::GrowableIOBuffer);
+  PacketFramer framer(buffer);
+  CastMessage message;
+  ChannelError error;
+  size_t message_length;
+
+  buffer->SetCapacity(PacketFramer::MessageHeader::max_message_size());
+  uint32 packet_len = test_proto_strs_[0].size();
+  memcpy(buffer->StartOfBuffer(), test_proto_strs_[0].data(), packet_len);
+
+  // Receive 1 byte of the header, framer demands 3 more bytes.
+  EXPECT_EQ(4u, framer.BytesRequested());
+  EXPECT_FALSE(framer.Ingest(1, &message, &message_length, &error));
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, error);
+  EXPECT_EQ(3u, framer.BytesRequested());
+
+  // Ingest remaining 3, expect that the framer has moved on to requesting the
+  // body contents.
+  EXPECT_FALSE(framer.Ingest(3, &message, &message_length, &error));
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, error);
+  EXPECT_EQ(packet_len - PacketFramer::MessageHeader::header_size(),
+            framer.BytesRequested());
+
+  // Remainder of packet sent over the wire.
+  EXPECT_TRUE(framer.Ingest(
+      framer.BytesRequested(), &message, &message_length, &error));
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, error);
+  EXPECT_EQ(message.SerializeAsString(), test_protos_[0].SerializeAsString());
+  EXPECT_EQ(4u, framer.BytesRequested());
+  EXPECT_EQ(message.SerializeAsString().size(), message_length);
+}
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions