Initial implementation of onbufferedamountlow

Source/modules/mediastream/RTCDataChannelTest.cpp

+// 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 "config.h"
+#include "modules/mediastream/RTCDataChannel.h"
+
+#include "bindings/core/v8/ExceptionStatePlaceholder.h"
+#include "core/dom/DOMArrayBuffer.h"
+#include "core/dom/DOMException.h"
+#include "core/dom/ExceptionCode.h"
+#include "core/events/Event.h"
+#include "platform/heap/Heap.h"
+#include "public/platform/WebRTCDataChannelHandler.h"
+#include "public/platform/WebUnitTestSupport.h"
+#include "public/platform/WebVector.h"
+#include "wtf/RefPtr.h"
+#include "wtf/testing/WTFTestHelpers.h"
+#include "wtf/text/WTFString.h"
+#include <gtest/gtest.h>
+
+namespace blink {
+namespace {
+
+class MockHandler final : public WebRTCDataChannelHandler {
+public:
+    MockHandler()
+        : m_client(0)
+        , m_state(WebRTCDataChannelHandlerClient::ReadyStateConnecting)
+        , m_bufferedAmount(0)
+    {
+    }
+    virtual void setClient(WebRTCDataChannelHandlerClient* client) { m_client = client; }

[tkent, 2015/06/09 23:47:27]

Remove |virtual|, and add |override| or |final|.
Same for other virtual member functions.

+    virtual WebString label() { return ""; }
+    virtual bool ordered() const { return true; }
+    virtual unsigned short maxRetransmitTime() const { return 0; }
+    virtual unsigned short maxRetransmits() const { return 0; }
+    virtual WebString protocol() const { return ""; }
+    virtual bool negotiated() const { return false; }
+    virtual unsigned short id() const { return 0; }
+
+    virtual WebRTCDataChannelHandlerClient::ReadyState state() const { return m_state; }
+    virtual unsigned long bufferedAmount() { return m_bufferedAmount; }
+    virtual bool sendStringData(const WebString& s)
+    {
+        m_bufferedAmount += s.length();
+        return true;
+    }
+    virtual bool sendRawData(const char* data, size_t length)
+    {
+        m_bufferedAmount += length;
+        return true;
+    }
+    virtual void close() { }
+
+    // Methods for testing.
+    void changeState(WebRTCDataChannelHandlerClient::ReadyState state)
+    {
+        m_state = state;
+        if (m_client) {
+            m_client->didChangeReadyState(m_state);
+        }
+    }
+    void drainBuffer(unsigned long bytes)
+    {
+        unsigned long oldBufferedAmount = m_bufferedAmount;
+        m_bufferedAmount -= bytes;
+        if (m_client) {
+            m_client->didDecreaseBufferedAmount(oldBufferedAmount);
+        }
+    }
+private:

[tkent, 2015/06/09 23:47:27]

nit: add a blank line before |private:|

+    WebRTCDataChannelHandlerClient* m_client;
+    WebRTCDataChannelHandlerClient::ReadyState m_state;
+    unsigned long m_bufferedAmount;
+};
+
+} // namespace
+
+TEST(RTCDataChannelTest, BufferedAmount)
+{
+    MockHandler* handler = new MockHandler();
+    RTCDataChannel* channel = RTCDataChannel::create(0, 0, adoptPtr(handler));
+
+    handler->changeState(WebRTCDataChannelHandlerClient::ReadyStateOpen);
+    String message(std::string(100, 'A').c_str());
+    channel->send(message, IGNORE_EXCEPTION);
+    EXPECT_EQ(100U, channel->bufferedAmount());
+}
+
+TEST(RTCDataChannelTest, BufferedAmountLow)
+{
+    MockHandler* handler = new MockHandler();
+    RTCDataChannel* channel = RTCDataChannel::create(0, 0, adoptPtr(handler));
+
+    // Add and drain 100 bytes
+    handler->changeState(WebRTCDataChannelHandlerClient::ReadyStateOpen);
+    String message(std::string(100, 'A').c_str());
+    channel->send(message, IGNORE_EXCEPTION);
+    EXPECT_EQ(1U, channel->m_scheduledEvents.size());
+    handler->drainBuffer(100);
+    EXPECT_EQ(2U, channel->m_scheduledEvents.size());
+    EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()->type().utf8().data()));
+
+    // Add and drain 1 byte
+    channel->send("A", IGNORE_EXCEPTION);
+    EXPECT_EQ(2U, channel->m_scheduledEvents.size());
+    handler->drainBuffer(1);
+    EXPECT_EQ(3U, channel->m_scheduledEvents.size());
+    EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()->type().utf8().data()));
+
+    // Set the threshold to 99 bytes, add 101, and drain 1 byte at a time.
+    channel->setBufferedAmountLowThreshold(99U);
+    channel->send(message, IGNORE_EXCEPTION); // Add 100 bytes.
+    channel->send("A", IGNORE_EXCEPTION); // Add 1 more byte.
+    handler->drainBuffer(1); // 100 bytes buffered.
+    EXPECT_EQ(3U, channel->m_scheduledEvents.size()); // No new events.
+    handler->drainBuffer(1); // 99 bytes buffered; event is emitted.
+    EXPECT_EQ(4U, channel->m_scheduledEvents.size()); // One new event.
+    EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()->type().utf8().data()));
+    handler->drainBuffer(1); // 98 bytes buffered.
+    channel->setBufferedAmountLowThreshold(97U);
+    EXPECT_EQ(4U, channel->m_scheduledEvents.size()); // No new events.
+    handler->drainBuffer(1); // 97 bytes buffered; event is emitted.
+    EXPECT_EQ(5U, channel->m_scheduledEvents.size()); // New event.
+    EXPECT_EQ("bufferedamountlow", std::string(channel->m_scheduledEvents.last()->type().utf8().data()));
+}
+
+} // namespace blink