Remove lock from SharedMemoryDataConsumerHandle::Context destructor

content/child/shared_memory_data_consumer_handle.cc

 // Copyright 2015 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/child/shared_memory_data_consumer_handle.h"
 
 #include <algorithm>
 #include <deque>
 #include <utility>
 
@@ skipping 71 matching lines @@
         // We post a task even in the writer thread in order to avoid a
         // reentrance problem as calling |on_reader_detached_| may manipulate
         // the context synchronously.
         writer_task_runner_->PostTask(FROM_HERE, on_reader_detached_);
       }
       Clear();
     }
   }
   void ClearQueue() {
     lock_.AssertAcquired();
-    for (auto* data : queue_) {
-      delete data;
-    }
     queue_.clear();
     first_offset_ = 0;
   }
   RequestPeer::ThreadSafeReceivedData* Top() {
     lock_.AssertAcquired();
-    return queue_.front();
+    return queue_.front().get();
   }
   void Push(std::unique_ptr<RequestPeer::ThreadSafeReceivedData> data) {
     lock_.AssertAcquired();
-    queue_.push_back(data.release());
+    queue_.push_back(std::move(data));
   }
   size_t first_offset() const {
     lock_.AssertAcquired();
     return first_offset_;
   }
   Result result() const {
     lock_.AssertAcquired();
     return result_;
   }
   void set_result(Result r) {
@@ skipping 66 matching lines @@
   }
   void set_is_handle_active(bool b) {
     lock_.AssertAcquired();
     is_handle_active_ = b;
   }
   void Consume(size_t s) {
     lock_.AssertAcquired();
     first_offset_ += s;
     auto* top = Top();
     if (static_cast<size_t>(top->length()) <= first_offset_) {
-      delete top;
       queue_.pop_front();
       first_offset_ = 0;
     }
   }
   bool is_two_phase_read_in_progress() const {
     lock_.AssertAcquired();
     return is_two_phase_read_in_progress_;
   }
   void set_is_two_phase_read_in_progress(bool b) {
     lock_.AssertAcquired();
@@ skipping 23 matching lines @@
     if (repost) {
       // We don't re-post the task when the runner changes while waiting for
       // this task because in this case a new reader is obtained and
       // notification is already done at the reader creation time if necessary.
       runner->PostTask(FROM_HERE,
                        base::Bind(&Context::NotifyInternal, this, false));
     }
   }
   void Clear() {
     lock_.AssertAcquired();
-    for (auto* data : queue_) {
-      delete data;
-    }
-    queue_.clear();
-    first_offset_ = 0;
+    ClearQueue();
     client_ = nullptr;
-    // Note this doesn't work in the destructor if |on_reader_detached_| is not
-    // null. We have an assert in the destructor.
     ResetOnReaderDetached();
   }
   // Must be called with |lock_| not aquired.
   void ResetOnReaderDetachedWithLock() {
     base::AutoLock lock(lock_);
     ResetOnReaderDetached();
   }
 
   friend class base::RefCountedThreadSafe<Context>;
-  ~Context() {
-    base::AutoLock lock(lock_);
-    DCHECK(on_reader_detached_.is_null());
-
-    // This is necessary because the queue stores raw pointers.
-    Clear();
-  }
+  ~Context() = default;
 
   base::Lock lock_;
   // |result_| stores the ultimate state of this handle if it has. Otherwise,
   // |Ok| is set.
   Result result_;
-  // TODO(yhirano): Use std::deque<std::unique_ptr<ThreadSafeReceivedData>>
-  // once it is allowed.
-  std::deque<RequestPeer::ThreadSafeReceivedData*> queue_;
+  std::deque<std::unique_ptr<RequestPeer::ThreadSafeReceivedData>> queue_;
   size_t first_offset_;
   Client* client_;
   scoped_refptr<base::SingleThreadTaskRunner> notification_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> writer_task_runner_;
   base::Closure on_reader_detached_;
   // We need this boolean variable to remember if |on_reader_detached_| is
   // callable because we need to reset |on_reader_detached_| only on the writer
   // thread and hence |on_reader_detached_.is_null()| is untrustworthy on
   // other threads.
   bool is_on_reader_detached_valid_;
@@ skipping 198 matching lines @@
 std::unique_ptr<blink::WebDataConsumerHandle::Reader>
 SharedMemoryDataConsumerHandle::obtainReader(Client* client) {
   return base::WrapUnique(new ReaderImpl(context_, client));
 }
 
 const char* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content