Remove stl_util's deletion functions from net/spdy/.

net/spdy/spdy_write_queue.cc

Index: net/spdy/spdy_write_queue.cc
diff --git a/net/spdy/spdy_write_queue.cc b/net/spdy/spdy_write_queue.cc
index cc0d787eaf85b825509bb99268a5ec33c4355dd7..50df9440a777541ffcf4cbc66c45eb4f08243a02 100644
--- a/net/spdy/spdy_write_queue.cc
+++ b/net/spdy/spdy_write_queue.cc
@@ -5,31 +5,33 @@
 #include "net/spdy/spdy_write_queue.h"
 
 #include <cstddef>
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_stream.h"
 
 namespace net {
 
-SpdyWriteQueue::PendingWrite::PendingWrite() : frame_producer(NULL) {}
+SpdyWriteQueue::PendingWrite::PendingWrite() {}
 
 SpdyWriteQueue::PendingWrite::PendingWrite(
     SpdyFrameType frame_type,
-    SpdyBufferProducer* frame_producer,
+    std::unique_ptr<SpdyBufferProducer> frame_producer,
     const base::WeakPtr<SpdyStream>& stream)
     : frame_type(frame_type),
-      frame_producer(frame_producer),
+      frame_producer(std::move(frame_producer)),
       stream(stream),
-      has_stream(stream.get() != NULL) {}
-
-SpdyWriteQueue::PendingWrite::PendingWrite(const PendingWrite& other) = default;
+      has_stream(stream.get() != nullptr) {}
 
 SpdyWriteQueue::PendingWrite::~PendingWrite() {}
 
+SpdyWriteQueue::PendingWrite::PendingWrite(PendingWrite&& other) = default;
+SpdyWriteQueue::PendingWrite& SpdyWriteQueue::PendingWrite::operator=(
+    PendingWrite&& other) = default;
+
 SpdyWriteQueue::SpdyWriteQueue() : removing_writes_(false) {}
 
 SpdyWriteQueue::~SpdyWriteQueue() {
@@ -53,8 +55,7 @@ void SpdyWriteQueue::Enqueue(RequestPriority priority,
   CHECK_LE(priority, MAXIMUM_PRIORITY);
   if (stream.get())
     DCHECK_EQ(stream->priority(), priority);
-  queue_[priority].push_back(
-      PendingWrite(frame_type, frame_producer.release(), stream));
+  queue_[priority].push_back({frame_type, std::move(frame_producer), stream});
 }
 
 bool SpdyWriteQueue::Dequeue(
@@ -64,10 +65,10 @@ bool SpdyWriteQueue::Dequeue(
   CHECK(!removing_writes_);
   for (int i = MAXIMUM_PRIORITY; i >= MINIMUM_PRIORITY; --i) {
     if (!queue_[i].empty()) {
-      PendingWrite pending_write = queue_[i].front();
+      PendingWrite pending_write = std::move(queue_[i].front());
       queue_[i].pop_front();
       *frame_type = pending_write.frame_type;
-      frame_producer->reset(pending_write.frame_producer);
+      *frame_producer = std::move(pending_write.frame_producer);
       *stream = pending_write.stream;
       if (pending_write.has_stream)
         DCHECK(stream->get());
@@ -92,74 +93,66 @@ void SpdyWriteQueue::RemovePendingWritesForStream(
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     if (priority == i)
       continue;
-    for (std::deque<PendingWrite>::const_iterator it = queue_[i].begin();
-         it != queue_[i].end(); ++it) {
+    for (auto it = queue_[i].begin(); it != queue_[i].end(); ++it)
       DCHECK_NE(it->stream.get(), stream.get());
-    }
   }
 #endif
 
   // Defer deletion until queue iteration is complete, as
   // SpdyBuffer::~SpdyBuffer() can result in callbacks into SpdyWriteQueue.
-  std::vector<SpdyBufferProducer*> erased_buffer_producers;
+  std::vector<std::unique_ptr<SpdyBufferProducer>> erased_buffer_producers;
 
   // Do the actual deletion and removal, preserving FIFO-ness.
-  std::deque<PendingWrite>* queue = &queue_[priority];
-  std::deque<PendingWrite>::iterator out_it = queue->begin();
-  for (std::deque<PendingWrite>::const_iterator it = queue->begin();
-       it != queue->end(); ++it) {
+  std::deque<PendingWrite>& queue = queue_[priority];
+  auto out_it = queue.begin();
+  for (auto it = queue.begin(); it != queue.end(); ++it) {
     if (it->stream.get() == stream.get()) {
-      erased_buffer_producers.push_back(it->frame_producer);
+      erased_buffer_producers.push_back(std::move(it->frame_producer));
     } else {
-      *out_it = *it;
+      *out_it = std::move(*it);
       ++out_it;
     }
   }
-  queue->erase(out_it, queue->end());
+  queue.erase(out_it, queue.end());
   removing_writes_ = false;
-  base::STLDeleteElements(&erased_buffer_producers);  // Invokes callbacks.
 }
 
 void SpdyWriteQueue::RemovePendingWritesForStreamsAfter(
     SpdyStreamId last_good_stream_id) {
   CHECK(!removing_writes_);
   removing_writes_ = true;
-  std::vector<SpdyBufferProducer*> erased_buffer_producers;
+  std::vector<std::unique_ptr<SpdyBufferProducer>> erased_buffer_producers;
 
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     // Do the actual deletion and removal, preserving FIFO-ness.
-    std::deque<PendingWrite>* queue = &queue_[i];
-    std::deque<PendingWrite>::iterator out_it = queue->begin();
-    for (std::deque<PendingWrite>::const_iterator it = queue->begin();
-         it != queue->end(); ++it) {
+    std::deque<PendingWrite>& queue = queue_[i];
+    auto out_it = queue.begin();
+    for (auto it = queue.begin(); it != queue.end(); ++it) {
       if (it->stream.get() && (it->stream->stream_id() > last_good_stream_id ||
                                it->stream->stream_id() == 0)) {
-        erased_buffer_producers.push_back(it->frame_producer);
+        erased_buffer_producers.push_back(std::move(it->frame_producer));
       } else {
-        *out_it = *it;
+        *out_it = std::move(*it);
         ++out_it;
       }
     }
-    queue->erase(out_it, queue->end());
+    queue.erase(out_it, queue.end());
   }
   removing_writes_ = false;
-  base::STLDeleteElements(&erased_buffer_producers);  // Invokes callbacks.
 }
 
 void SpdyWriteQueue::Clear() {
   CHECK(!removing_writes_);
   removing_writes_ = true;
-  std::vector<SpdyBufferProducer*> erased_buffer_producers;
+  std::vector<std::unique_ptr<SpdyBufferProducer>> erased_buffer_producers;
 
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
-    for (std::deque<PendingWrite>::iterator it = queue_[i].begin();
-         it != queue_[i].end(); ++it) {
-      erased_buffer_producers.push_back(it->frame_producer);
+    for (auto it = queue_[i].begin(); it != queue_[i].end(); ++it) {
+      erased_buffer_producers.push_back(std::move(it->frame_producer));
     }
     queue_[i].clear();
   }
   removing_writes_ = false;
-  base::STLDeleteElements(&erased_buffer_producers);  // Invokes callbacks.
 }
 
 }  // namespace net