Added a debug info UI for Blimp

blimp/net/stream_packet_reader_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/sys_byteorder.h"
+#include "blimp/net/blimp_connection_statistics.h"
 #include "blimp/net/common.h"
 #include "blimp/net/stream_packet_reader.h"
 #include "blimp/net/test_common.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Mock;
 using testing::NotNull;
 using testing::Return;
 using testing::SaveArg;
 using testing::WithArg;
 
 namespace blimp {
 namespace {
 
 class StreamPacketReaderTest : public testing::Test {
  public:
   StreamPacketReaderTest()
       : buffer_(new net::GrowableIOBuffer),
         test_msg_("U WOT M8"),
-        data_reader_(&socket_) {}
+        data_reader_(&socket_, &statistics_) {}
 
   ~StreamPacketReaderTest() override {}
 
   void ReadPacket() { data_reader_.ReadPacket(buffer_, callback_.callback()); }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<net::GrowableIOBuffer> buffer_;
   std::string test_msg_;
   net::TestCompletionCallback callback_;
   testing::StrictMock<MockStreamSocket> socket_;
   testing::InSequence sequence_;
+  BlimpConnectionStatistics statistics_;
   StreamPacketReader data_reader_;
 };
 
 // Successful read with 1 async header read and 1 async payload read.
 TEST_F(StreamPacketReaderTest, ReadAsyncHeaderAsyncPayload) {
   net::CompletionCallback socket_cb;
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)));
@@ skipping 89 matching lines @@
       .RetiresOnSaturation();
 
   // Read the second message's payload synchronously.
   EXPECT_CALL(socket_, Read(NotNull(), test_msg2.size(), _))
       .WillOnce(
           DoAll(FillBufferFromString<0>(test_msg2), Return(test_msg2.size())))
       .RetiresOnSaturation();
 
   ReadPacket();
   ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  EXPECT_EQ(static_cast<int>(test_msg_.size()),
+            statistics_.Get(BlimpConnectionStatistics::BYTES_RECEIVED));
 
   ReadPacket();
   ASSERT_EQ(static_cast<int>(test_msg2.size()), callback_.WaitForResult());
+  EXPECT_EQ(static_cast<int>(test_msg_.size() + test_msg2.size()),
+            statistics_.Get(BlimpConnectionStatistics::BYTES_RECEIVED));
 
   EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg2.size(), test_msg2));
   EXPECT_FALSE(callback_.have_result());
 }
 
 // Successful read of 2 messages, header and payload reads all completing
 // asynchronously with no partial results.
 TEST_F(StreamPacketReaderTest, ReadMultipleMessagesAsync) {
   net::TestCompletionCallback read_cb1;
   net::TestCompletionCallback read_cb2;
@@ skipping 134 matching lines @@
   ReadPacket();
   cb.Run(net::ERR_FAILED);
   EXPECT_EQ(net::ERR_FAILED, callback_.WaitForResult());
 }
 
 // Verify that async header read completions don't break us if the
 // StreamPacketReader object was destroyed.
 TEST_F(StreamPacketReaderTest, ReaderDeletedDuringAsyncHeaderRead) {
   net::CompletionCallback cb;
   net::TestCompletionCallback test_cb;
-  std::unique_ptr<StreamPacketReader> reader(new StreamPacketReader(&socket_));
+  std::unique_ptr<StreamPacketReader> reader(
+      new StreamPacketReader(&socket_, &statistics_));
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       SaveArg<2>(&cb), Return(net::ERR_IO_PENDING)));
 
   reader->ReadPacket(buffer_, callback_.callback());
   reader.reset();                  // Delete the reader object.
   cb.Run(kPacketHeaderSizeBytes);  // Complete the socket operation.
 }
 
 // Verify that async payload read completions don't break us if the
 // StreamPacketReader object was destroyed.
 TEST_F(StreamPacketReaderTest, ReaderDeletedDuringAsyncPayloadRead) {
   net::CompletionCallback cb;
-  std::unique_ptr<StreamPacketReader> reader(new StreamPacketReader(&socket_));
+  std::unique_ptr<StreamPacketReader> reader(
+      new StreamPacketReader(&socket_, &statistics_));
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       Return(kPacketHeaderSizeBytes)));
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(DoAll(SaveArg<2>(&cb), Return(net::ERR_IO_PENDING)));
   reader->ReadPacket(buffer_, callback_.callback());
 
   reader.reset();           // Delete the reader object.
   cb.Run(net::ERR_FAILED);  // Complete the socket operation.
@@ skipping 17 matching lines @@
           FillBufferFromString<0>(EncodeHeader(kMaxPacketPayloadSizeBytes + 1)),
           Return(kPacketHeaderSizeBytes)));
 
   ReadPacket();
   EXPECT_EQ(net::ERR_INVALID_RESPONSE, callback_.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace blimp