extensions/browser/api/cast_channel/cast_transport_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/cast_channel/cast_transport.h"
   6
   7 #include <stddef.h>
   8 #include <queue>
   9
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/simple_test_clock.h"
  13 #include "extensions/browser/api/cast_channel/cast_framer.h"
  14 #include "extensions/browser/api/cast_channel/cast_socket.h"
  15 #include "extensions/browser/api/cast_channel/cast_test_util.h"
  16 #include "extensions/browser/api/cast_channel/logger.h"
  17 #include "extensions/browser/api/cast_channel/logger_util.h"
  18 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
  19 #include "net/base/completion_callback.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/log/test_net_log.h"
  22 #include "net/socket/socket.h"
  23 #include "testing/gmock/include/gmock/gmock.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 using testing::_;
  27 using testing::DoAll;
  28 using testing::InSequence;
  29 using testing::Invoke;
  30 using testing::NotNull;
  31 using testing::Return;
  32 using testing::WithArg;
  33
  34 namespace extensions {
  35 namespace api {
  36 namespace cast_channel {
  37 namespace {
  38
  39 const int kChannelId = 0;
  40
  41 // Mockable placeholder for write completion events.
  42 class CompleteHandler {
  43  public:
  44   CompleteHandler() {}
  45   MOCK_METHOD1(Complete, void(int result));
  46
  47  private:
  48   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
  49 };
  50
  51 // Creates a CastMessage proto with the bare minimum required fields set.
  52 CastMessage CreateCastMessage() {
  53   CastMessage output;
  54   output.set_protocol_version(CastMessage::CASTV2_1_0);
  55   output.set_namespace_("x");
  56   output.set_source_id("source");
  57   output.set_destination_id("destination");
  58   output.set_payload_type(CastMessage::STRING);
  59   output.set_payload_utf8("payload");
  60   return output;
  61 }
  62
  63 // FIFO queue of completion callbacks. Outstanding write operations are
  64 // Push()ed into the queue. Callback completion is simulated by invoking
  65 // Pop() in the same order as Push().
  66 class CompletionQueue {
  67  public:
  68   CompletionQueue() {}
  69   ~CompletionQueue() { CHECK_EQ(0u, cb_queue_.size()); }
  70
  71   // Enqueues a pending completion callback.
  72   void Push(const net::CompletionCallback& cb) { cb_queue_.push(cb); }
  73   // Runs the next callback and removes it from the queue.
  74   void Pop(int rv) {
  75     CHECK_GT(cb_queue_.size(), 0u);
  76     cb_queue_.front().Run(rv);
  77     cb_queue_.pop();
  78   }
  79
  80  private:
  81   std::queue<net::CompletionCallback> cb_queue_;
  82   DISALLOW_COPY_AND_ASSIGN(CompletionQueue);
  83 };
  84
  85 // GMock action that reads data from an IOBuffer and writes it to a string
  86 // variable.
  87 //
  88 //   buf_idx (template parameter 0): 0-based index of the net::IOBuffer
  89 //                                   in the function mock arg list.
  90 //   size_idx (template parameter 1): 0-based index of the byte count arg.
  91 //   str: pointer to the string which will receive data from the buffer.
  92 ACTION_TEMPLATE(ReadBufferToString,
  93                 HAS_2_TEMPLATE_PARAMS(int, buf_idx, int, size_idx),
  94                 AND_1_VALUE_PARAMS(str)) {
  95   str->assign(testing::get<buf_idx>(args)->data(),
  96               testing::get<size_idx>(args));
  97 }
  98
  99 // GMock action that writes data from a string to an IOBuffer.
 100 //
 101 //   buf_idx (template parameter 0): 0-based index of the IOBuffer arg.
 102 //   str: the string containing data to be written to the IOBuffer.
 103 ACTION_TEMPLATE(FillBufferFromString,
 104                 HAS_1_TEMPLATE_PARAMS(int, buf_idx),
 105                 AND_1_VALUE_PARAMS(str)) {
 106   memcpy(testing::get<buf_idx>(args)->data(), str.data(), str.size());
 107 }
 108
 109 // GMock action that enqueues a write completion callback in a queue.
 110 //
 111 //   buf_idx (template parameter 0): 0-based index of the CompletionCallback.
 112 //   completion_queue: a pointer to the CompletionQueue.
 113 ACTION_TEMPLATE(EnqueueCallback,
 114                 HAS_1_TEMPLATE_PARAMS(int, cb_idx),
 115                 AND_1_VALUE_PARAMS(completion_queue)) {
 116   completion_queue->Push(testing::get<cb_idx>(args));
 117 }
 118
 119 }  // namespace
 120
 121 class MockSocket : public net::Socket {
 122  public:
 123   MOCK_METHOD3(Read,
 124                int(net::IOBuffer* buf,
 125                    int buf_len,
 126                    const net::CompletionCallback& callback));
 127
 128   MOCK_METHOD3(Write,
 129                int(net::IOBuffer* buf,
 130                    int buf_len,
 131                    const net::CompletionCallback& callback));
 132
 133   virtual int SetReceiveBufferSize(int32 size) {
 134     NOTREACHED();
 135     return 0;
 136   }
 137
 138   virtual int SetSendBufferSize(int32 size) {
 139     NOTREACHED();
 140     return 0;
 141   }
 142 };
 143
 144 class CastTransportTest : public testing::Test {
 145  public:
 146   CastTransportTest()
 147       : logger_(
 148             new Logger(make_scoped_ptr<base::Clock>(new base::SimpleTestClock),
 149                        base::Time())) {
 150     delegate_ = new MockCastTransportDelegate;
 151     transport_.reset(new CastTransportImpl(&mock_socket_, kChannelId,
 152                                            CreateIPEndPointForTest(),
 153                                            auth_type_, logger_));
 154     transport_->SetReadDelegate(make_scoped_ptr(delegate_));
 155   }
 156   ~CastTransportTest() override {}
 157
 158  protected:
 159   // Runs all pending tasks in the message loop.
 160   void RunPendingTasks() {
 161     base::RunLoop run_loop;
 162     run_loop.RunUntilIdle();
 163   }
 164
 165   base::MessageLoop message_loop_;
 166   MockCastTransportDelegate* delegate_;
 167   MockSocket mock_socket_;
 168   ChannelAuthType auth_type_;
 169   Logger* logger_;
 170   scoped_ptr<CastTransport> transport_;
 171 };
 172
 173 // ----------------------------------------------------------------------------
 174 // Asynchronous write tests
 175 TEST_F(CastTransportTest, TestFullWriteAsync) {
 176   CompletionQueue socket_cbs;
 177   CompleteHandler write_handler;
 178   std::string output;
 179
 180   CastMessage message = CreateCastMessage();
 181   std::string serialized_message;
 182   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 183
 184   EXPECT_CALL(mock_socket_, Write(NotNull(), serialized_message.size(), _))
 185       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output),
 186                       EnqueueCallback<2>(&socket_cbs),
 187                       Return(net::ERR_IO_PENDING)));
 188   EXPECT_CALL(write_handler, Complete(net::OK));
 189   transport_->SendMessage(
 190       message,
 191       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 192   RunPendingTasks();
 193   socket_cbs.Pop(serialized_message.size());
 194   RunPendingTasks();
 195   EXPECT_EQ(serialized_message, output);
 196 }
 197
 198 TEST_F(CastTransportTest, TestPartialWritesAsync) {
 199   InSequence seq;
 200   CompletionQueue socket_cbs;
 201   CompleteHandler write_handler;
 202   std::string output;
 203
 204   CastMessage message = CreateCastMessage();
 205   std::string serialized_message;
 206   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 207
 208   // Only one byte is written.
 209   EXPECT_CALL(mock_socket_,
 210               Write(NotNull(), static_cast<int>(serialized_message.size()), _))
 211       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output),
 212                       EnqueueCallback<2>(&socket_cbs),
 213                       Return(net::ERR_IO_PENDING)));
 214   // Remainder of bytes are written.
 215   EXPECT_CALL(
 216       mock_socket_,
 217       Write(NotNull(), static_cast<int>(serialized_message.size() - 1), _))
 218       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output),
 219                       EnqueueCallback<2>(&socket_cbs),
 220                       Return(net::ERR_IO_PENDING)));
 221
 222   transport_->SendMessage(
 223       message,
 224       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 225   RunPendingTasks();
 226   EXPECT_EQ(serialized_message, output);
 227   socket_cbs.Pop(1);
 228   RunPendingTasks();
 229
 230   EXPECT_CALL(write_handler, Complete(net::OK));
 231   socket_cbs.Pop(serialized_message.size() - 1);
 232   RunPendingTasks();
 233   EXPECT_EQ(serialized_message.substr(1, serialized_message.size() - 1),
 234             output);
 235 }
 236
 237 TEST_F(CastTransportTest, TestWriteFailureAsync) {
 238   CompletionQueue socket_cbs;
 239   CompleteHandler write_handler;
 240   CastMessage message = CreateCastMessage();
 241   EXPECT_CALL(mock_socket_, Write(NotNull(), _, _)).WillOnce(
 242       DoAll(EnqueueCallback<2>(&socket_cbs), Return(net::ERR_IO_PENDING)));
 243   EXPECT_CALL(write_handler, Complete(net::ERR_FAILED));
 244   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
 245   transport_->SendMessage(
 246       message,
 247       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 248   RunPendingTasks();
 249   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
 250   RunPendingTasks();
 251   EXPECT_EQ(proto::SOCKET_WRITE, logger_->GetLastErrors(kChannelId).event_type);
 252   EXPECT_EQ(net::ERR_CONNECTION_RESET,
 253             logger_->GetLastErrors(kChannelId).net_return_value);
 254 }
 255
 256 // ----------------------------------------------------------------------------
 257 // Synchronous write tests
 258 TEST_F(CastTransportTest, TestFullWriteSync) {
 259   CompleteHandler write_handler;
 260   std::string output;
 261   CastMessage message = CreateCastMessage();
 262   std::string serialized_message;
 263   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 264   EXPECT_CALL(mock_socket_, Write(NotNull(), serialized_message.size(), _))
 265       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output),
 266                       Return(serialized_message.size())));
 267   EXPECT_CALL(write_handler, Complete(net::OK));
 268   transport_->SendMessage(
 269       message,
 270       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 271   RunPendingTasks();
 272   EXPECT_EQ(serialized_message, output);
 273 }
 274
 275 TEST_F(CastTransportTest, TestPartialWritesSync) {
 276   InSequence seq;
 277   CompleteHandler write_handler;
 278   std::string output;
 279
 280   CastMessage message = CreateCastMessage();
 281   std::string serialized_message;
 282   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 283
 284   // Only one byte is written.
 285   EXPECT_CALL(mock_socket_, Write(NotNull(), serialized_message.size(), _))
 286       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output), Return(1)));
 287   // Remainder of bytes are written.
 288   EXPECT_CALL(mock_socket_, Write(NotNull(), serialized_message.size() - 1, _))
 289       .WillOnce(DoAll(ReadBufferToString<0, 1>(&output),
 290                       Return(serialized_message.size() - 1)));
 291
 292   EXPECT_CALL(write_handler, Complete(net::OK));
 293   transport_->SendMessage(
 294       message,
 295       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 296   RunPendingTasks();
 297   EXPECT_EQ(serialized_message.substr(1, serialized_message.size() - 1),
 298             output);
 299 }
 300
 301 TEST_F(CastTransportTest, TestWriteFailureSync) {
 302   CompleteHandler write_handler;
 303   CastMessage message = CreateCastMessage();
 304   EXPECT_CALL(mock_socket_, Write(NotNull(), _, _))
 305       .WillOnce(Return(net::ERR_CONNECTION_RESET));
 306   EXPECT_CALL(write_handler, Complete(net::ERR_FAILED));
 307   transport_->SendMessage(
 308       message,
 309       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
 310   RunPendingTasks();
 311   EXPECT_EQ(proto::SOCKET_WRITE, logger_->GetLastErrors(kChannelId).event_type);
 312   EXPECT_EQ(net::ERR_CONNECTION_RESET,
 313             logger_->GetLastErrors(kChannelId).net_return_value);
 314 }
 315
 316 // ----------------------------------------------------------------------------
 317 // Asynchronous read tests
 318 TEST_F(CastTransportTest, TestFullReadAsync) {
 319   InSequence s;
 320   CompletionQueue socket_cbs;
 321
 322   CastMessage message = CreateCastMessage();
 323   std::string serialized_message;
 324   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 325   EXPECT_CALL(*delegate_, Start());
 326
 327   // Read bytes [0, 3].
 328   EXPECT_CALL(mock_socket_,
 329               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 330       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 331                       EnqueueCallback<2>(&socket_cbs),
 332                       Return(net::ERR_IO_PENDING)));
 333
 334   // Read bytes [4, n].
 335   EXPECT_CALL(mock_socket_,
 336               Read(NotNull(),
 337                    serialized_message.size() -
 338                        MessageFramer::MessageHeader::header_size(),
 339                    _))
 340       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 341                           MessageFramer::MessageHeader::header_size(),
 342                           serialized_message.size() -
 343                               MessageFramer::MessageHeader::header_size())),
 344                       EnqueueCallback<2>(&socket_cbs),
 345                       Return(net::ERR_IO_PENDING)))
 346       .RetiresOnSaturation();
 347
 348   EXPECT_CALL(*delegate_, OnMessage(EqualsProto(message)));
 349   EXPECT_CALL(mock_socket_,
 350               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 351       .WillOnce(Return(net::ERR_IO_PENDING));
 352   transport_->Start();
 353   RunPendingTasks();
 354   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
 355   socket_cbs.Pop(serialized_message.size() -
 356                  MessageFramer::MessageHeader::header_size());
 357   RunPendingTasks();
 358 }
 359
 360 TEST_F(CastTransportTest, TestPartialReadAsync) {
 361   InSequence s;
 362   CompletionQueue socket_cbs;
 363
 364   CastMessage message = CreateCastMessage();
 365   std::string serialized_message;
 366   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 367
 368   EXPECT_CALL(*delegate_, Start());
 369
 370   // Read bytes [0, 3].
 371   EXPECT_CALL(mock_socket_,
 372               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 373       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 374                       EnqueueCallback<2>(&socket_cbs),
 375                       Return(net::ERR_IO_PENDING)))
 376       .RetiresOnSaturation();
 377   // Read bytes [4, n-1].
 378   EXPECT_CALL(mock_socket_,
 379               Read(NotNull(),
 380                    serialized_message.size() -
 381                        MessageFramer::MessageHeader::header_size(),
 382                    _))
 383       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 384                           MessageFramer::MessageHeader::header_size(),
 385                           serialized_message.size() -
 386                               MessageFramer::MessageHeader::header_size() - 1)),
 387                       EnqueueCallback<2>(&socket_cbs),
 388                       Return(net::ERR_IO_PENDING)))
 389       .RetiresOnSaturation();
 390   // Read final byte.
 391   EXPECT_CALL(mock_socket_, Read(NotNull(), 1, _))
 392       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 393                           serialized_message.size() - 1, 1)),
 394                       EnqueueCallback<2>(&socket_cbs),
 395                       Return(net::ERR_IO_PENDING)))
 396       .RetiresOnSaturation();
 397   EXPECT_CALL(*delegate_, OnMessage(EqualsProto(message)));
 398   transport_->Start();
 399   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
 400   socket_cbs.Pop(serialized_message.size() -
 401                  MessageFramer::MessageHeader::header_size() - 1);
 402   EXPECT_CALL(mock_socket_,
 403               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 404       .WillOnce(Return(net::ERR_IO_PENDING));
 405   socket_cbs.Pop(1);
 406 }
 407
 408 TEST_F(CastTransportTest, TestReadErrorInHeaderAsync) {
 409   CompletionQueue socket_cbs;
 410
 411   CastMessage message = CreateCastMessage();
 412   std::string serialized_message;
 413   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 414
 415   EXPECT_CALL(*delegate_, Start());
 416
 417   // Read bytes [0, 3].
 418   EXPECT_CALL(mock_socket_,
 419               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 420       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 421                       EnqueueCallback<2>(&socket_cbs),
 422                       Return(net::ERR_IO_PENDING)))
 423       .RetiresOnSaturation();
 424
 425   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
 426   transport_->Start();
 427   // Header read failure.
 428   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
 429   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
 430   EXPECT_EQ(net::ERR_CONNECTION_RESET,
 431             logger_->GetLastErrors(kChannelId).net_return_value);
 432 }
 433
 434 TEST_F(CastTransportTest, TestReadErrorInBodyAsync) {
 435   CompletionQueue socket_cbs;
 436
 437   CastMessage message = CreateCastMessage();
 438   std::string serialized_message;
 439   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 440
 441   EXPECT_CALL(*delegate_, Start());
 442
 443   // Read bytes [0, 3].
 444   EXPECT_CALL(mock_socket_,
 445               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 446       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 447                       EnqueueCallback<2>(&socket_cbs),
 448                       Return(net::ERR_IO_PENDING)))
 449       .RetiresOnSaturation();
 450   // Read bytes [4, n-1].
 451   EXPECT_CALL(mock_socket_,
 452               Read(NotNull(),
 453                    serialized_message.size() -
 454                        MessageFramer::MessageHeader::header_size(),
 455                    _))
 456       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 457                           MessageFramer::MessageHeader::header_size(),
 458                           serialized_message.size() -
 459                               MessageFramer::MessageHeader::header_size() - 1)),
 460                       EnqueueCallback<2>(&socket_cbs),
 461                       Return(net::ERR_IO_PENDING)))
 462       .RetiresOnSaturation();
 463   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
 464   transport_->Start();
 465   // Header read is OK.
 466   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
 467   // Body read fails.
 468   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
 469   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
 470   EXPECT_EQ(net::ERR_CONNECTION_RESET,
 471             logger_->GetLastErrors(kChannelId).net_return_value);
 472 }
 473
 474 TEST_F(CastTransportTest, TestReadCorruptedMessageAsync) {
 475   CompletionQueue socket_cbs;
 476
 477   CastMessage message = CreateCastMessage();
 478   std::string serialized_message;
 479   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 480
 481   // Corrupt the serialized message body(set it to X's).
 482   for (size_t i = MessageFramer::MessageHeader::header_size();
 483        i < serialized_message.size();
 484        ++i) {
 485     serialized_message[i] = 'x';
 486   }
 487
 488   EXPECT_CALL(*delegate_, Start());
 489   // Read bytes [0, 3].
 490   EXPECT_CALL(mock_socket_,
 491               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 492       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 493                       EnqueueCallback<2>(&socket_cbs),
 494                       Return(net::ERR_IO_PENDING)))
 495       .RetiresOnSaturation();
 496   // Read bytes [4, n].
 497   EXPECT_CALL(mock_socket_,
 498               Read(NotNull(),
 499                    serialized_message.size() -
 500                        MessageFramer::MessageHeader::header_size(),
 501                    _))
 502       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 503                           MessageFramer::MessageHeader::header_size(),
 504                           serialized_message.size() -
 505                               MessageFramer::MessageHeader::header_size() - 1)),
 506                       EnqueueCallback<2>(&socket_cbs),
 507                       Return(net::ERR_IO_PENDING)))
 508       .RetiresOnSaturation();
 509
 510   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE));
 511   transport_->Start();
 512   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
 513   socket_cbs.Pop(serialized_message.size() -
 514                  MessageFramer::MessageHeader::header_size());
 515 }
 516
 517 // ----------------------------------------------------------------------------
 518 // Synchronous read tests
 519 TEST_F(CastTransportTest, TestFullReadSync) {
 520   InSequence s;
 521   CastMessage message = CreateCastMessage();
 522   std::string serialized_message;
 523   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 524
 525   EXPECT_CALL(*delegate_, Start());
 526
 527   // Read bytes [0, 3].
 528   EXPECT_CALL(mock_socket_,
 529               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 530       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 531                       Return(MessageFramer::MessageHeader::header_size())))
 532       .RetiresOnSaturation();
 533   // Read bytes [4, n].
 534   EXPECT_CALL(mock_socket_,
 535               Read(NotNull(),
 536                    serialized_message.size() -
 537                        MessageFramer::MessageHeader::header_size(),
 538                    _))
 539       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 540                           MessageFramer::MessageHeader::header_size(),
 541                           serialized_message.size() -
 542                               MessageFramer::MessageHeader::header_size())),
 543                       Return(serialized_message.size() -
 544                              MessageFramer::MessageHeader::header_size())))
 545       .RetiresOnSaturation();
 546   EXPECT_CALL(*delegate_, OnMessage(EqualsProto(message)));
 547   // Async result in order to discontinue the read loop.
 548   EXPECT_CALL(mock_socket_,
 549               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 550       .WillOnce(Return(net::ERR_IO_PENDING));
 551   transport_->Start();
 552 }
 553
 554 TEST_F(CastTransportTest, TestPartialReadSync) {
 555   InSequence s;
 556
 557   CastMessage message = CreateCastMessage();
 558   std::string serialized_message;
 559   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 560
 561   EXPECT_CALL(*delegate_, Start());
 562
 563   // Read bytes [0, 3].
 564   EXPECT_CALL(mock_socket_,
 565               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 566       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 567                       Return(MessageFramer::MessageHeader::header_size())))
 568       .RetiresOnSaturation();
 569   // Read bytes [4, n-1].
 570   EXPECT_CALL(mock_socket_,
 571               Read(NotNull(),
 572                    serialized_message.size() -
 573                        MessageFramer::MessageHeader::header_size(),
 574                    _))
 575       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 576                           MessageFramer::MessageHeader::header_size(),
 577                           serialized_message.size() -
 578                               MessageFramer::MessageHeader::header_size() - 1)),
 579                       Return(serialized_message.size() -
 580                              MessageFramer::MessageHeader::header_size() - 1)))
 581       .RetiresOnSaturation();
 582   // Read final byte.
 583   EXPECT_CALL(mock_socket_, Read(NotNull(), 1, _))
 584       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 585                           serialized_message.size() - 1, 1)),
 586                       Return(1)))
 587       .RetiresOnSaturation();
 588   EXPECT_CALL(*delegate_, OnMessage(EqualsProto(message)));
 589   EXPECT_CALL(mock_socket_,
 590               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 591       .WillOnce(Return(net::ERR_IO_PENDING));
 592   transport_->Start();
 593 }
 594
 595 TEST_F(CastTransportTest, TestReadErrorInHeaderSync) {
 596   InSequence s;
 597   CastMessage message = CreateCastMessage();
 598   std::string serialized_message;
 599   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 600
 601   EXPECT_CALL(*delegate_, Start());
 602
 603   // Read bytes [0, 3].
 604   EXPECT_CALL(mock_socket_,
 605               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 606       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 607                       Return(net::ERR_CONNECTION_RESET)))
 608       .RetiresOnSaturation();
 609   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
 610   transport_->Start();
 611 }
 612
 613 TEST_F(CastTransportTest, TestReadErrorInBodySync) {
 614   CastMessage message = CreateCastMessage();
 615   std::string serialized_message;
 616   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 617
 618   EXPECT_CALL(*delegate_, Start());
 619
 620   // Read bytes [0, 3].
 621   EXPECT_CALL(mock_socket_,
 622               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 623       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 624                       Return(MessageFramer::MessageHeader::header_size())))
 625       .RetiresOnSaturation();
 626   // Read bytes [4, n-1].
 627   EXPECT_CALL(mock_socket_,
 628               Read(NotNull(),
 629                    serialized_message.size() -
 630                        MessageFramer::MessageHeader::header_size(),
 631                    _))
 632       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 633                           MessageFramer::MessageHeader::header_size(),
 634                           serialized_message.size() -
 635                               MessageFramer::MessageHeader::header_size() - 1)),
 636                       Return(net::ERR_CONNECTION_RESET)))
 637       .RetiresOnSaturation();
 638   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
 639   transport_->Start();
 640   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
 641   EXPECT_EQ(net::ERR_CONNECTION_RESET,
 642             logger_->GetLastErrors(kChannelId).net_return_value);
 643 }
 644
 645 TEST_F(CastTransportTest, TestReadCorruptedMessageSync) {
 646   InSequence s;
 647   CastMessage message = CreateCastMessage();
 648   std::string serialized_message;
 649   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 650
 651   // Corrupt the serialized message body(set it to X's).
 652   for (size_t i = MessageFramer::MessageHeader::header_size();
 653        i < serialized_message.size();
 654        ++i) {
 655     serialized_message[i] = 'x';
 656   }
 657
 658   EXPECT_CALL(*delegate_, Start());
 659
 660   // Read bytes [0, 3].
 661   EXPECT_CALL(mock_socket_,
 662               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
 663       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
 664                       Return(MessageFramer::MessageHeader::header_size())))
 665       .RetiresOnSaturation();
 666   // Read bytes [4, n].
 667   EXPECT_CALL(mock_socket_,
 668               Read(NotNull(),
 669                    serialized_message.size() -
 670                        MessageFramer::MessageHeader::header_size(),
 671                    _))
 672       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
 673                           MessageFramer::MessageHeader::header_size(),
 674                           serialized_message.size() -
 675                               MessageFramer::MessageHeader::header_size() - 1)),
 676                       Return(serialized_message.size() -
 677                              MessageFramer::MessageHeader::header_size())))
 678       .RetiresOnSaturation();
 679   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE));
 680   transport_->Start();
 681 }
 682 }  // namespace cast_channel
 683 }  // namespace api
 684 }  // namespace extensions