Guard SpdyWriteQueue::Enqueue, and test all reentrancy points.

net/spdy/spdy_write_queue_unittest.cc

 // Copyright (c) 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.
 
 #include "net/spdy/spdy_write_queue.h"
 
 #include <cstddef>
 #include <cstring>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
+using std::string;
+
+const char kOriginal[] = "original";
+const char kRequed[] = "requed";

[willchan no longer on Chromium, 2014/05/07 21:27:47]

spelling nazi here, requed=>requeued :)

[Johnny, 2014/05/08 02:49:14]

Done.

+
 class SpdyWriteQueueTest : public ::testing::Test {};
 
 // Makes a SpdyFrameProducer producing a frame with the data in the
 // given string.
 scoped_ptr<SpdyBufferProducer> StringToProducer(const std::string& s) {
   scoped_ptr<char[]> data(new char[s.size()]);
   std::memcpy(data.get(), s.data(), s.size());
   return scoped_ptr<SpdyBufferProducer>(
       new SimpleBufferProducer(
           scoped_ptr<SpdyBuffer>(
               new SpdyBuffer(
                   scoped_ptr<SpdyFrame>(
                       new SpdyFrame(data.release(), s.size(), true))))));
 }
 
 // Makes a SpdyBufferProducer producing a frame with the data in the
 // given int (converted to a string).
 scoped_ptr<SpdyBufferProducer> IntToProducer(int i) {
   return StringToProducer(base::IntToString(i));
 }
 
+// Producer whose produced buffer will enqueue yet another buffer into the
+// SpdyWriteQueue upon destruction.
+class RequeingBufferProducer : public SpdyBufferProducer {
+ public:
+  RequeingBufferProducer(SpdyWriteQueue* queue) {
+    buffer_.reset(new SpdyBuffer(kOriginal, arraysize(kOriginal)));
+    buffer_->AddConsumeCallback(
+        base::Bind(RequeingBufferProducer::ConsumeCallback, queue));
+  }
+
+  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() OVERRIDE {
+    return buffer_.Pass();
+  }
+
+  static void ConsumeCallback(SpdyWriteQueue* queue,
+                              size_t size,
+                              SpdyBuffer::ConsumeSource source) {
+    scoped_ptr<SpdyBufferProducer> producer(new SimpleBufferProducer(
+        scoped_ptr<SpdyBuffer>(new SpdyBuffer(kRequed, arraysize(kRequed)))));
+
+    queue->Enqueue(
+        MEDIUM, RST_STREAM, producer.Pass(), base::WeakPtr<SpdyStream>());
+  }
+
+ private:
+  scoped_ptr<SpdyBuffer> buffer_;
+};
+
 // Produces a frame with the given producer and returns a copy of its
 // data as a string.
 std::string ProducerToString(scoped_ptr<SpdyBufferProducer> producer) {
   scoped_ptr<SpdyBuffer> buffer = producer->ProduceBuffer();
   return std::string(buffer->GetRemainingData(), buffer->GetRemainingSize());
 }
 
 // Produces a frame with the given producer and returns a copy of its
 // data as an int (converted from a string).
 int ProducerToInt(scoped_ptr<SpdyBufferProducer> producer) {
@@ skipping 183 matching lines @@
   }
 
   write_queue.Clear();
 
   SpdyFrameType frame_type = DATA;
   scoped_ptr<SpdyBufferProducer> frame_producer;
   base::WeakPtr<SpdyStream> stream;
   EXPECT_FALSE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
 }
 
+TEST_F(SpdyWriteQueueTest, RequeingProducerWithoutReentrance) {
+  SpdyWriteQueue queue;
+  queue.Enqueue(
+      DEFAULT_PRIORITY,
+      SYN_STREAM,
+      scoped_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
+      base::WeakPtr<SpdyStream>());
+  {
+    SpdyFrameType frame_type;
+    scoped_ptr<SpdyBufferProducer> producer;
+    base::WeakPtr<SpdyStream> stream;
+
+    EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
+    EXPECT_TRUE(queue.IsEmpty());
+    EXPECT_EQ(string(kOriginal), producer->ProduceBuffer()->GetRemainingData());
+  }
+  // |producer| was destroyed, and a buffer is re-queued.
+  EXPECT_FALSE(queue.IsEmpty());
+
+  SpdyFrameType frame_type;
+  scoped_ptr<SpdyBufferProducer> producer;
+  base::WeakPtr<SpdyStream> stream;
+
+  EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
+  EXPECT_EQ(string(kRequed), producer->ProduceBuffer()->GetRemainingData());
+}
+
+TEST_F(SpdyWriteQueueTest, ReentranceOnClear) {
+  SpdyWriteQueue queue;
+  queue.Enqueue(
+      DEFAULT_PRIORITY,
+      SYN_STREAM,
+      scoped_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
+      base::WeakPtr<SpdyStream>());
+
+  queue.Clear();
+  EXPECT_FALSE(queue.IsEmpty());
+
+  SpdyFrameType frame_type;
+  scoped_ptr<SpdyBufferProducer> producer;
+  base::WeakPtr<SpdyStream> stream;
+
+  EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &stream));
+  EXPECT_EQ(string(kRequed), producer->ProduceBuffer()->GetRemainingData());
+}
+
+TEST_F(SpdyWriteQueueTest, ReentranceOnRemovePendingWritesAfter) {
+  scoped_ptr<SpdyStream> stream(MakeTestStream(DEFAULT_PRIORITY));
+  stream->set_stream_id(2);
+
+  SpdyWriteQueue queue;
+  queue.Enqueue(
+      DEFAULT_PRIORITY,
+      SYN_STREAM,
+      scoped_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
+      stream->GetWeakPtr());
+
+  queue.RemovePendingWritesForStreamsAfter(1);
+  EXPECT_FALSE(queue.IsEmpty());
+
+  SpdyFrameType frame_type;
+  scoped_ptr<SpdyBufferProducer> producer;
+  base::WeakPtr<SpdyStream> weak_stream;
+
+  EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &weak_stream));
+  EXPECT_EQ(string(kRequed), producer->ProduceBuffer()->GetRemainingData());
+}
+
+TEST_F(SpdyWriteQueueTest, ReentranceOnRemovePendingWritesForStream) {
+  scoped_ptr<SpdyStream> stream(MakeTestStream(DEFAULT_PRIORITY));
+  stream->set_stream_id(2);
+
+  SpdyWriteQueue queue;
+  queue.Enqueue(
+      DEFAULT_PRIORITY,
+      SYN_STREAM,
+      scoped_ptr<SpdyBufferProducer>(new RequeingBufferProducer(&queue)),
+      stream->GetWeakPtr());
+
+  queue.RemovePendingWritesForStream(stream->GetWeakPtr());
+  EXPECT_FALSE(queue.IsEmpty());
+
+  SpdyFrameType frame_type;
+  scoped_ptr<SpdyBufferProducer> producer;
+  base::WeakPtr<SpdyStream> weak_stream;
+
+  EXPECT_TRUE(queue.Dequeue(&frame_type, &producer, &weak_stream));
+  EXPECT_EQ(string(kRequed), producer->ProduceBuffer()->GetRemainingData());
+}
+
 }  // namespace
 
 }  // namespace net