Allow continuous request dispatch below the throttle rate

content/renderer/scheduler/resource_dispatch_throttler_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/resource_dispatch_throttler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
@@ skipping 57 matching lines @@
 
 class ResourceDispatchThrottlerForTest : public ResourceDispatchThrottler {
  public:
   ResourceDispatchThrottlerForTest(IPC::Sender* sender,
                                    scheduler::RendererScheduler* scheduler)
       : ResourceDispatchThrottler(
             sender,
             scheduler,
             base::TimeDelta::FromSecondsD(kFlushPeriodSeconds),
             kRequestsPerFlush),
+        now_(base::TimeTicks() + base::TimeDelta::FromDays(1)),
         flush_scheduled_(false) {}
   ~ResourceDispatchThrottlerForTest() override {}
 
   void Advance(base::TimeDelta delta) { now_ += delta; }
 
   bool RunScheduledFlush() {
     if (!flush_scheduled_)
       return false;
 
     flush_scheduled_ = false;
@@ skipping 157 matching lines @@
   SetHighPriorityWorkAnticipated(true);
 
   for (size_t i = 0; i < kRequestsPerFlush * 2; ++i) {
     Advance(base::TimeDelta::FromSecondsD(kFlushPeriodSeconds * 2));
     RequestResource();
     EXPECT_EQ(1U, GetAndResetSentMessageCount());
     EXPECT_FALSE(FlushScheduled());
   }
 }
 
+TEST_F(ResourceDispatchThrottlerTest, NotThrottledIfSendRateSufficientlyLow) {
+  SetHighPriorityWorkAnticipated(true);
+
+  // Continuous dispatch of resource requests below the allowed send rate
+  // should never throttled.
+  const base::TimeDelta kAllowedContinuousSendInterval =
+      base::TimeDelta::FromSecondsD((kFlushPeriodSeconds / kRequestsPerFlush) +
+                                    .00001);
+  for (size_t i = 0; i < kRequestsPerFlush * 10; ++i) {
+    Advance(kAllowedContinuousSendInterval);
+    RequestResource();
+    EXPECT_EQ(1U, GetAndResetSentMessageCount());
+    EXPECT_FALSE(FlushScheduled());
+  }
+}
+
+TEST_F(ResourceDispatchThrottlerTest, ThrottledIfSendRateSufficientlyHigh) {
+  SetHighPriorityWorkAnticipated(true);
+
+  // Continuous dispatch of resource requests above the allowed send rate
+  // should be throttled.
+  const base::TimeDelta kThrottledContinuousSendInterval =
+      base::TimeDelta::FromSecondsD((kFlushPeriodSeconds / kRequestsPerFlush) -
+                                    .00001);
+
+  for (size_t i = 0; i < kRequestsPerFlush * 10; ++i) {
+    Advance(kThrottledContinuousSendInterval);
+    RequestResource();
+    // Only the first batch of requests under the limit should be unthrottled.
+    if (i < kRequestsPerFlush) {
+      EXPECT_EQ(1U, GetAndResetSentMessageCount());
+      EXPECT_FALSE(FlushScheduled());
+    } else {
+      EXPECT_EQ(0U, GetAndResetSentMessageCount());
+      EXPECT_TRUE(FlushScheduled());
+    }
+  }
+}
+
 TEST_F(ResourceDispatchThrottlerTest, NotThrottledIfSyncMessage) {
   SetHighPriorityWorkAnticipated(true);
 
   RequestResourceSync();
   EXPECT_EQ(1U, GetAndResetSentMessageCount());
 
   // Saturate the queue.
   for (size_t i = 0; i < kRequestsPerFlush * 2; ++i)
     RequestResource();
   ASSERT_EQ(kRequestsPerFlush, GetAndResetSentMessageCount());
@@ skipping 100 matching lines @@
     EXPECT_EQ(priority_msg.type(), ResourceHostMsg_DidChangePriority::ID);
     EXPECT_EQ(cancel_msg.type(), ResourceHostMsg_CancelRequest::ID);
 
     EXPECT_EQ(GetRequestId(request_msg), GetRequestId(priority_msg));
     EXPECT_EQ(GetRequestId(request_msg) - 1, GetRequestId(cancel_msg));
   }
   EXPECT_FALSE(FlushScheduled());
 }
 
 }  // namespace content