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