Create dedicated class for handling wire message formatting and parsing.

extensions/browser/api/cast_channel/cast_socket_unittest.cc

 // Copyright 2014 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 "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"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/timer/mock_timer.h"
 #include "extensions/browser/api/cast_channel/cast_channel.pb.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
@@ skipping 174 matching lines @@
     net::IPAddressNumber number;
     number.push_back(192);
     number.push_back(0);
     number.push_back(0);
     number.push_back(1);
     return net::IPEndPoint(number, 8009);
   }
 
   // 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() - MessageFramer::MessageHeader::header_size();
   }
 
   virtual ~TestCastSocket() {
   }
 
   // Helpers to set mock results for various operations.
   void SetupTcp1Connect(net::IoMode mode, int result) {
     tcp_connect_data_[0].reset(new net::MockConnect(mode, result));
   }
   void SetupSsl1Connect(net::IoMode mode, int result) {
@@ skipping 33 matching lines @@
   }
   void AddReadResult(net::IoMode mode, int result) {
     AddReadResult(net::MockRead(mode, result));
   }
   void AddReadResult(net::IoMode mode, const char* data, int data_len) {
     AddReadResult(net::MockRead(mode, data, data_len));
   }
   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, MessageFramer::MessageHeader::header_size());
+    AddReadResult(
+        mode, data + MessageFramer::MessageHeader::header_size(), body_size);
   }
   void AddReadResultForMessage(net::IoMode mode,
                                const std::string& msg,
                                size_t ch_size) {
     size_t msg_size = msg.size();
     const char* data = msg.c_str();
     for (size_t offset = 0; offset < msg_size; offset += ch_size) {
       if (offset + ch_size > msg_size)
         ch_size = msg_size - offset;
       AddReadResult(mode, data + offset, ch_size);
@@ skipping 83 matching lines @@
             base::TimeTicks())) {}
   virtual ~CastSocketTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Create a few test messages
     for (size_t i = 0; i < arraysize(test_messages_); i++) {
       CreateStringMessage("urn:cast", "1", "2", kTestData[i],
                           &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(
+          MessageFramer::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"
   // (useful for negative test cases.)
   void SetupAuthMessage(
       const char* auth_namespace = "urn:x-cast:com.google.cast.tp.deviceauth") {
     // Create a test auth request.
     CastMessage request;
     CreateAuthChallengeMessage(&request);
-    ASSERT_TRUE(CastSocket::Serialize(request, &auth_request_));
+    ASSERT_TRUE(MessageFramer::Serialize(request, &auth_request_));
 
     // Create a test auth reply.
     MessageInfo reply;
     CreateBinaryMessage(
         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(MessageFramer::Serialize(reply_msg, &auth_reply_));
   }
 
   void CreateCastSocket() {
     socket_ = TestCastSocket::Create(&mock_delegate_, logger_.get());
   }
 
   void CreateCastSocketSecure() {
     socket_ = TestCastSocket::CreateSecure(&mock_delegate_, logger_.get());
   }
 
@@ skipping 542 matching lines @@
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write error - very large message
 TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
   CreateCastSocket();
   ConnectHelper();
   SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
-  size_t size = CastSocket::MessageHeader::max_message_size() + 1;
+  size_t size = MessageFramer::MessageHeader::max_message_size() + 1;
   test_messages_[0].data.reset(
       new base::StringValue(std::string(size, 'a')));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
@@ skipping 197 matching lines @@
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test read error - header parse error
 TEST_F(CastSocketTest, TestReadHeaderParseError) {
   CreateCastSocket();
   SetupAuthMessage();
-  uint32 body_size = base::HostToNet32(
-      CastSocket::MessageHeader::max_message_size() + 1);
+
+  uint32 body_size =
+      base::HostToNet32(MessageFramer::MessageHeader::max_message_size() + 1);
   // TODO(munjal): Add a method to cast_message_util.h to serialize messages
   char header[sizeof(body_size)];
   memcpy(&header, &body_size, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
                       A<const LastErrors&>()));
   ConnectHelper();
 
@@ skipping 16 matching lines @@
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 
+TEST_F(CastSocketTest, TestMessageFramerCompleteMessage) {
+  scoped_refptr<net::GrowableIOBuffer> buffer(new net::GrowableIOBuffer);
+  MessageFramer framer(buffer);
+  ChannelError error;
+  size_t message_length;
+
+  buffer->SetCapacity(MessageFramer::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_EQ(NULL, framer.Ingest(1, &message_length, &error).get());
+  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_EQ(NULL, framer.Ingest(3, &message_length, &error).get());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, error);
+  EXPECT_EQ(packet_len - MessageFramer::MessageHeader::header_size(),
+            framer.BytesRequested());
+
+  // Remainder of packet sent over the wire.
+  scoped_ptr<CastMessage> message;
+  message = framer.Ingest(framer.BytesRequested(), &message_length, &error);
+  EXPECT_NE(static_cast<CastMessage*>(NULL), message.get());
+  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