Reland "Throttle resource message requests during user interaction"

content/renderer/scheduler/throttled_message_sender_unittest.cc

+// Copyright 2014 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 "content/renderer/scheduler/throttled_message_sender.h"
+
+#include "base/memory/scoped_vector.h"
+#include "content/common/resource_messages.h"
+#include "content/renderer/scheduler/null_renderer_scheduler.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {
+
+const size_t kDefaultMaxMessagesPerSecond = 120;
+const size_t kMessagesPerFlush = kDefaultMaxMessagesPerSecond / 60;
+
+const int kRoutingId = 1;
+
+}  // namespace
+
+class ThrottledMessageSenderTest : public testing::Test,
+                                   public IPC::Sender,
+                                   public NullRendererScheduler {
+ public:
+  ThrottledMessageSenderTest()
+      : throttled_sender_(
+            new ThrottledMessageSender(this,
+                                       this,
+                                       kDefaultMaxMessagesPerSecond)),
+        yield_(false),
+        next_request_id_(0) {}
+  ~ThrottledMessageSenderTest() override {}
+
+  // IPC::Sender implementation:
+  bool Send(IPC::Message* msg) override {
+    sent_messages_.push_back(msg);
+    return true;
+  }
+
+  // RendererScheduler implementation:
+  bool ShouldYieldForHighPriorityWork() override { return yield_; }
+
+  void SetShouldYieldForHighPriorityWork(bool yield) { yield_ = yield; }
+
+  void Run(base::TimeDelta delay) {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::MessageLoop::QuitClosure(), delay);
+    base::MessageLoop::current()->Run();
+  }
+
+  void RunOneFlush() { Run(base::TimeDelta::FromSecondsD(1.f / 60.f)); }
+
+  bool SendMessage() {
+    return throttled_sender_->Send(new ResourceHostMsg_RequestResource(
+        kRoutingId, ++next_request_id_, ResourceHostMsg_Request()));
+  }
+
+  bool SendSyncMessage() {
+    SyncLoadResult result;
+    return throttled_sender_->Send(new ResourceHostMsg_SyncLoad(
+        kRoutingId, ++next_request_id_, ResourceHostMsg_Request(), &result));
+  }
+
+  size_t GetAndResetSentMessageCount() {
+    size_t sent_message_count = sent_messages_.size();
+    sent_messages_.clear();
+    return sent_message_count;
+  }
+
+ protected:
+  ScopedVector<IPC::Message> sent_messages_;
+
+ private:
+  base::MessageLoopForUI message_loop_;
+  scoped_ptr<ThrottledMessageSender> throttled_sender_;
+  bool yield_;
+  int next_request_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThrottledMessageSenderTest);
+};
+
+TEST_F(ThrottledMessageSenderTest, NotThrottledByDefault) {
+  SetShouldYieldForHighPriorityWork(false);
+  for (size_t i = 0; i < kMessagesPerFlush * 2; ++i) {
+    SendMessage();
+    EXPECT_EQ(i + 1, sent_messages_.size());
+  }
+}
+
+TEST_F(ThrottledMessageSenderTest, NotThrottledIfSendLimitNotReached) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush; ++i) {
+    SendMessage();
+    EXPECT_EQ(i + 1, sent_messages_.size());
+  }
+}
+
+TEST_F(ThrottledMessageSenderTest, ThrottledWhenHighPriorityWork) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush; ++i)
+    SendMessage();
+  ASSERT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+
+  SendMessage();
+  EXPECT_EQ(0U, sent_messages_.size());
+
+  RunOneFlush();
+  EXPECT_EQ(1U, sent_messages_.size());
+}
+
+TEST_F(ThrottledMessageSenderTest, ThrottledWhenDeferredMessageQueueNonEmpty) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush; ++i)
+    SendMessage();
+  ASSERT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+
+  SendMessage();
+  EXPECT_EQ(0U, sent_messages_.size());
+  SetShouldYieldForHighPriorityWork(false);
+  SendMessage();
+  EXPECT_EQ(0U, sent_messages_.size());
+
+  RunOneFlush();
+  EXPECT_EQ(2U, sent_messages_.size());
+}
+
+TEST_F(ThrottledMessageSenderTest, NotThrottledIfSufficientTimePassed) {
+  SetShouldYieldForHighPriorityWork(true);
+
+  for (size_t i = 0; i < kMessagesPerFlush * 2; ++i) {
+    SendMessage();
+    EXPECT_EQ(1U, GetAndResetSentMessageCount());
+    RunOneFlush();
+  }
+}
+
+TEST_F(ThrottledMessageSenderTest, SyncFlush) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush; ++i)
+    SendMessage();
+  ASSERT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+
+  SendMessage();
+  EXPECT_EQ(0U, sent_messages_.size());
+  SendSyncMessage();
+  EXPECT_EQ(2U, sent_messages_.size());
+}
+
+TEST_F(ThrottledMessageSenderTest, MultipleFlushes) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush * 4; ++i)
+    SendMessage();
+  ASSERT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+
+  for (size_t i = 0; i < 3; ++i) {
+    RunOneFlush();
+    EXPECT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+  }
+}
+
+TEST_F(ThrottledMessageSenderTest, MultipleFlushesWhileReceiving) {
+  SetShouldYieldForHighPriorityWork(true);
+  for (size_t i = 0; i < kMessagesPerFlush * 4; ++i)
+    SendMessage();
+  ASSERT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+
+  for (size_t i = 0; i < 3; ++i) {
+    RunOneFlush();
+    EXPECT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+    for (size_t i = 0; i < kMessagesPerFlush; ++i)
+      SendMessage();
+  }
+
+  for (size_t i = 0; i < 3; ++i) {
+    RunOneFlush();
+    EXPECT_EQ(kMessagesPerFlush, GetAndResetSentMessageCount());
+  }
+
+  RunOneFlush();
+  EXPECT_EQ(0U, sent_messages_.size());
+}
+
+}  // namespace content