Add size limit to LLEventBatchThrottle like LLEventBatch.

The new behavior is that it will flush when either the pending batch has grown
to the specified size, or the time interval has expired.

2 files changed, 47 insertions, 18 deletions

diff --git a/indra/llcommon/lleventfilter.cpp b/indra/llcommon/lleventfilter.cpp
index ddd7d5547a..9fb18dc67d 100644
--- a/indra/llcommon/lleventfilter.cpp
+++ b/indra/llcommon/lleventfilter.cpp
@@ -206,10 +206,8 @@ void LLEventBatch::flush()
 bool LLEventBatch::post(const LLSD& event)
 {
     mBatch.append(event);
-    if (mBatch.size() >= mBatchSize)
-    {
-        flush();
-    }
+    // calling setSize(same) performs the very check we want
+    setSize(mBatchSize);
     return false;
 }
 
@@ -377,12 +375,14 @@ F32  LLEventThrottle::timerGetRemaining() const
 /*****************************************************************************
 *   LLEventBatchThrottle
 *****************************************************************************/
-LLEventBatchThrottle::LLEventBatchThrottle(F32 interval):
-    LLEventThrottle(interval)
+LLEventBatchThrottle::LLEventBatchThrottle(F32 interval, std::size_t size):
+    LLEventThrottle(interval),
+    mBatchSize(size)
 {}
 
-LLEventBatchThrottle::LLEventBatchThrottle(LLEventPump& source, F32 interval):
-    LLEventThrottle(source, interval)
+LLEventBatchThrottle::LLEventBatchThrottle(LLEventPump& source, F32 interval, std::size_t size):
+    LLEventThrottle(source, interval),
+    mBatchSize(size)
 {}
 
 bool LLEventBatchThrottle::post(const LLSD& event)
@@ -390,5 +390,22 @@ bool LLEventBatchThrottle::post(const LLSD& event)
     // simply retrieve pending value and append the new event to it
     LLSD partial = pending();
     partial.append(event);
-    return LLEventThrottle::post(partial);
+    bool ret = LLEventThrottle::post(partial);
+    // The post() call above MIGHT have called flush() already. If it did,
+    // then pending() was reset to empty. If it did not, though, but the batch
+    // size has grown to the limit, flush() anyway. If there's a limit at all,
+    // of course. Calling setSize(same) performs the very check we want.
+    setSize(mBatchSize);
+    return ret;
+}
+
+void LLEventBatchThrottle::setSize(std::size_t size)
+{
+    mBatchSize = size;
+    // Changing the size might mean that we have to flush NOW. Don't forget
+    // that 0 means unlimited.
+    if (mBatchSize && pending().size() >= mBatchSize)
+    {
+        flush();
+    }
 }
diff --git a/indra/llcommon/lleventfilter.h b/indra/llcommon/lleventfilter.h
index cae18bfd86..ccbbc8bd25 100644
--- a/indra/llcommon/lleventfilter.h
+++ b/indra/llcommon/lleventfilter.h
@@ -270,14 +270,15 @@ private:
  * For a deferred event, the LLSD blob delivered to listeners is from the most
  * recent deferred post() call. However, a sender may obtain the previous
  * event blob by calling pending(), modifying it as desired and post()ing the
- * new value. Each time an event is delivered to listeners, the pending()
- * value is reset to isUndefined().
+ * new value. (See LLEventBatchThrottle.) Each time an event is delivered to
+ * listeners, the pending() value is reset to isUndefined().
  *
  * You may also call flush() to immediately pass along any deferred events to
  * all listeners.
  *
  * @NOTE This is an abstract base class so that, for testing, we can use an
- * alternate "timer" that doesn't actually consume real time.
+ * alternate "timer" that doesn't actually consume real time. See
+ * LLEventThrottle.
  */
 class LL_COMMON_API LLEventThrottleBase: public LLEventFilter
 {
@@ -348,20 +349,31 @@ private:
 };
 
 /**
- * LLEventBatchThrottle: like LLEventThrottle, it refuses to pass events to
- * listeners more often than once per specified time interval.
- * Like LLEventBatch, it accumulates pending events into an LLSD Array.
+ * LLEventBatchThrottle: like LLEventThrottle, it's reluctant to pass events
+ * to listeners more often than once per specified time interval -- but only
+ * reluctant, since exceeding the specified batch size limit can cause it to
+ * deliver accumulated events sooner. Like LLEventBatch, it accumulates
+ * pending events into an LLSD Array, optionally flushing when the batch grows
+ * to a certain size.
  */
 class LLEventBatchThrottle: public LLEventThrottle
 {
 public:
-    // pass time interval
-    LLEventBatchThrottle(F32 interval);
+    // pass time interval and (optionally) max batch size; 0 means batch can
+    // grow arbitrarily large
+    LLEventBatchThrottle(F32 interval, std::size_t size = 0);
     // construct and connect
-    LLEventBatchThrottle(LLEventPump& source, F32 interval);
+    LLEventBatchThrottle(LLEventPump& source, F32 interval, std::size_t size = 0);
 
     // append a new event to current batch
     virtual bool post(const LLSD& event);
+
+    // query or reset batch size
+    std::size_t getSize() const { return mBatchSize; }
+    void setSize(std::size_t size);
+
+private:
+    std::size_t mBatchSize;
 };
 
 #endif /* ! defined(LL_LLEVENTFILTER_H) */