OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 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 "config.h" |
| 6 #include "modules/mediastream/RTCDataChannel.h" |
| 7 |
| 8 #include "bindings/core/v8/ExceptionStatePlaceholder.h" |
| 9 #include "core/dom/DOMArrayBuffer.h" |
| 10 #include "core/dom/DOMException.h" |
| 11 #include "core/dom/ExceptionCode.h" |
| 12 #include "core/events/Event.h" |
| 13 #include "platform/heap/Heap.h" |
| 14 #include "public/platform/WebRTCDataChannelHandler.h" |
| 15 #include "public/platform/WebUnitTestSupport.h" |
| 16 #include "public/platform/WebVector.h" |
| 17 #include "wtf/RefPtr.h" |
| 18 #include "wtf/text/WTFString.h" |
| 19 #include <gtest/gtest.h> |
| 20 |
| 21 namespace blink { |
| 22 namespace { |
| 23 |
| 24 class MockHandler final : public WebRTCDataChannelHandler { |
| 25 public: |
| 26 MockHandler() |
| 27 : m_client(0) |
| 28 , m_state(WebRTCDataChannelHandlerClient::ReadyStateConnecting) |
| 29 , m_bufferedAmount(0) |
| 30 { |
| 31 } |
| 32 void setClient(WebRTCDataChannelHandlerClient* client) override { m_client =
client; } |
| 33 WebString label() override { return WebString(""); } |
| 34 bool ordered() const override { return true; } |
| 35 unsigned short maxRetransmitTime() const override { return 0; } |
| 36 unsigned short maxRetransmits() const override { return 0; } |
| 37 WebString protocol() const override { return WebString(""); } |
| 38 bool negotiated() const override { return false; } |
| 39 unsigned short id() const override { return 0; } |
| 40 |
| 41 WebRTCDataChannelHandlerClient::ReadyState state() const override { return m
_state; } |
| 42 unsigned long bufferedAmount() override { return m_bufferedAmount; } |
| 43 bool sendStringData(const WebString& s) override |
| 44 { |
| 45 m_bufferedAmount += s.length(); |
| 46 return true; |
| 47 } |
| 48 bool sendRawData(const char* data, size_t length) override |
| 49 { |
| 50 m_bufferedAmount += length; |
| 51 return true; |
| 52 } |
| 53 void close() override { } |
| 54 |
| 55 // Methods for testing. |
| 56 void changeState(WebRTCDataChannelHandlerClient::ReadyState state) |
| 57 { |
| 58 m_state = state; |
| 59 if (m_client) { |
| 60 m_client->didChangeReadyState(m_state); |
| 61 } |
| 62 } |
| 63 void drainBuffer(unsigned long bytes) |
| 64 { |
| 65 unsigned long oldBufferedAmount = m_bufferedAmount; |
| 66 m_bufferedAmount -= bytes; |
| 67 if (m_client) { |
| 68 m_client->didDecreaseBufferedAmount(oldBufferedAmount); |
| 69 } |
| 70 } |
| 71 |
| 72 private: |
| 73 WebRTCDataChannelHandlerClient* m_client; |
| 74 WebRTCDataChannelHandlerClient::ReadyState m_state; |
| 75 unsigned long m_bufferedAmount; |
| 76 }; |
| 77 |
| 78 } // namespace |
| 79 |
| 80 TEST(RTCDataChannelTest, BufferedAmount) |
| 81 { |
| 82 MockHandler* handler = new MockHandler(); |
| 83 RTCDataChannel* channel = RTCDataChannel::create(0, 0, adoptPtr(handler)); |
| 84 |
| 85 handler->changeState(WebRTCDataChannelHandlerClient::ReadyStateOpen); |
| 86 String message(std::string(100, 'A').c_str()); |
| 87 channel->send(message, IGNORE_EXCEPTION); |
| 88 EXPECT_EQ(100U, channel->bufferedAmount()); |
| 89 } |
| 90 |
| 91 TEST(RTCDataChannelTest, BufferedAmountLow) |
| 92 { |
| 93 MockHandler* handler = new MockHandler(); |
| 94 RTCDataChannel* channel = RTCDataChannel::create(0, 0, adoptPtr(handler)); |
| 95 |
| 96 // Add and drain 100 bytes |
| 97 handler->changeState(WebRTCDataChannelHandlerClient::ReadyStateOpen); |
| 98 String message(std::string(100, 'A').c_str()); |
| 99 channel->send(message, IGNORE_EXCEPTION); |
| 100 EXPECT_EQ(100U, channel->bufferedAmount()); |
| 101 EXPECT_EQ(1U, channel->m_scheduledEvents.size()); |
| 102 |
| 103 handler->drainBuffer(100); |
| 104 EXPECT_EQ(0U, channel->bufferedAmount()); |
| 105 EXPECT_EQ(2U, channel->m_scheduledEvents.size()); |
| 106 EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()
->type().utf8().data())); |
| 107 |
| 108 // Add and drain 1 byte |
| 109 channel->send("A", IGNORE_EXCEPTION); |
| 110 EXPECT_EQ(1U, channel->bufferedAmount()); |
| 111 EXPECT_EQ(2U, channel->m_scheduledEvents.size()); |
| 112 |
| 113 handler->drainBuffer(1); |
| 114 EXPECT_EQ(0U, channel->bufferedAmount()); |
| 115 EXPECT_EQ(3U, channel->m_scheduledEvents.size()); |
| 116 EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()
->type().utf8().data())); |
| 117 |
| 118 // Set the threshold to 99 bytes, add 101, and drain 1 byte at a time. |
| 119 channel->setBufferedAmountLowThreshold(99U); |
| 120 channel->send(message, IGNORE_EXCEPTION); |
| 121 EXPECT_EQ(100U, channel->bufferedAmount()); |
| 122 |
| 123 channel->send("A", IGNORE_EXCEPTION); |
| 124 EXPECT_EQ(101U, channel->bufferedAmount()); |
| 125 |
| 126 handler->drainBuffer(1); |
| 127 EXPECT_EQ(100U, channel->bufferedAmount()); |
| 128 EXPECT_EQ(3U, channel->m_scheduledEvents.size()); // No new events. |
| 129 |
| 130 handler->drainBuffer(1); |
| 131 EXPECT_EQ(99U, channel->bufferedAmount()); |
| 132 EXPECT_EQ(4U, channel->m_scheduledEvents.size()); // One new event. |
| 133 EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()
->type().utf8().data())); |
| 134 |
| 135 handler->drainBuffer(1); |
| 136 EXPECT_EQ(98U, channel->bufferedAmount()); |
| 137 |
| 138 channel->setBufferedAmountLowThreshold(97U); |
| 139 EXPECT_EQ(4U, channel->m_scheduledEvents.size()); // No new events. |
| 140 |
| 141 handler->drainBuffer(1); |
| 142 EXPECT_EQ(97U, channel->bufferedAmount()); |
| 143 EXPECT_EQ(5U, channel->m_scheduledEvents.size()); // New event. |
| 144 EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()
->type().utf8().data())); |
| 145 } |
| 146 |
| 147 } // namespace blink |
OLD | NEW |