Mojo: DataPipe: Implement "may discard" mode for simple writes.

mojo/system/local_data_pipe.cc

 // Copyright 2013 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.
 
 // TODO(vtl): I currently potentially overflow in doing index calculations.
 // E.g., |start_index_| and |current_num_bytes_| fit into a |uint32_t|, but
 // their sum may not. This is bad and poses a security risk. (We're currently
 // saved by the limit on capacity -- the maximum size of the buffer, checked in
 // |DataPipe::ValidateOptions()|, is currently sufficiently small.
 
@@ skipping 33 matching lines @@
   }
   AwakeConsumerWaitersForStateChangeNoLock();
 }
 
 MojoResult LocalDataPipe::ProducerWriteDataImplNoLock(const void* elements,
                                                       uint32_t* num_bytes,
                                                       bool all_or_none) {
   DCHECK_EQ(*num_bytes % element_num_bytes(), 0u);
   DCHECK_GT(*num_bytes, 0u);
 
-  // TODO(vtl): Consider this return value.
-  if (all_or_none && *num_bytes > capacity_num_bytes() - current_num_bytes_)
-    return MOJO_RESULT_OUT_OF_RANGE;
+  size_t num_bytes_to_write = 0;
+  if (may_discard()) {
+    if (all_or_none && *num_bytes > capacity_num_bytes())
+      return MOJO_RESULT_OUT_OF_RANGE;
 
-  size_t num_bytes_to_write =
-      std::min(static_cast<size_t>(*num_bytes),
-               capacity_num_bytes() - current_num_bytes_);
+    num_bytes_to_write = std::min(static_cast<size_t>(*num_bytes),
+                                  capacity_num_bytes());
+    if (num_bytes_to_write > capacity_num_bytes() - current_num_bytes_) {
+      // Discard as much as needed (discard oldest first).
+      size_t num_bytes_to_discard =
+          num_bytes_to_write - (capacity_num_bytes() - current_num_bytes_);
+      start_index_ += num_bytes_to_discard;
+      start_index_ %= capacity_num_bytes();
+      current_num_bytes_ -= num_bytes_to_discard;
+    }
+  } else {
+    // TODO(vtl): Consider this return value. Maybe "out of range" when greater

[darin (slow to review), 2014/01/06 21:29:28]

hmm, your approach makes sense to me.

+    // than capacity, and "should wait" for the other case?
+    if (all_or_none && *num_bytes > capacity_num_bytes() - current_num_bytes_) {
+      return (*num_bytes > capacity_num_bytes()) ? MOJO_RESULT_OUT_OF_RANGE :
+                                                   MOJO_RESULT_SHOULD_WAIT;
+    }
+
+    num_bytes_to_write = std::min(static_cast<size_t>(*num_bytes),
+                                  capacity_num_bytes() - current_num_bytes_);
+  }
   if (num_bytes_to_write == 0)
     return MOJO_RESULT_SHOULD_WAIT;
 
   // The amount we can write in our first |memcpy()|.
   size_t num_bytes_to_write_first =
       std::min(num_bytes_to_write, GetMaxNumBytesToWriteNoLock());
   // Do the first (and possibly only) |memcpy()|.
   size_t first_write_index =
       (start_index_ + current_num_bytes_) % capacity_num_bytes();
   EnsureBufferNoLock();
@@ skipping 252 matching lines @@
 }
 
 size_t LocalDataPipe::GetMaxNumBytesToReadNoLock() {
   if (start_index_ + current_num_bytes_ > capacity_num_bytes())
     return capacity_num_bytes() - start_index_;
   return current_num_bytes_;
 }
 
 }  // namespace system
 }  // namespace mojo