content: Change auto to not deduce raw pointers.

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_) {
+    for (auto* data : queue_) {
       delete data;
     }
     queue_.clear();
     first_offset_ = 0;
   }
   RequestPeer::ThreadSafeReceivedData* Top() {
     lock_.AssertAcquired();
     return queue_.front();
   }
   void Push(std::unique_ptr<RequestPeer::ThreadSafeReceivedData> data) {
@@ skipping 76 matching lines @@
     lock_.AssertAcquired();
     return is_handle_active_;
   }
   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();
+    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_;
   }
@@ skipping 25 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_) {
+    for (auto* data : queue_) {
       delete data;
     }
     queue_.clear();
     first_offset_ = 0;
     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.
@@ skipping 139 matching lines @@
   size_t total_read_size = 0;
   *read_size_to_return = 0;
 
   if (context_->result() == Ok && context_->is_two_phase_read_in_progress())
     context_->set_result(UnexpectedError);
 
   if (context_->result() != Ok && context_->result() != Done)
     return context_->result();
 
   while (!context_->IsEmpty() && total_read_size < size) {
-    const auto& top = context_->Top();
+    auto* top = context_->Top();
     size_t readable = top->length() - context_->first_offset();
     size_t writable = size - total_read_size;
     size_t read_size = std::min(readable, writable);
     const char* begin = top->payload() + context_->first_offset();
     std::copy(begin, begin + read_size,
               static_cast<char*>(data) + total_read_size);
     total_read_size += read_size;
     context_->Consume(read_size);
   }
   *read_size_to_return = total_read_size;
@@ skipping 16 matching lines @@
   if (context_->result() == Ok && context_->is_two_phase_read_in_progress())
     context_->set_result(UnexpectedError);
 
   if (context_->result() != Ok && context_->result() != Done)
     return context_->result();
 
   if (context_->IsEmpty())
     return context_->result() == Done ? Done : ShouldWait;
 
   context_->set_is_two_phase_read_in_progress(true);
-  const auto& top = context_->Top();
+  auto* top = context_->Top();
   *buffer = top->payload() + context_->first_offset();
   *available = top->length() - context_->first_offset();
 
   return Ok;
 }
 
 Result SharedMemoryDataConsumerHandle::ReaderImpl::endRead(size_t read_size) {
   base::AutoLock lock(context_->lock());
 
   if (!context_->is_two_phase_read_in_progress())
@@ skipping 37 matching lines @@
 SharedMemoryDataConsumerHandle::ReaderImpl*
 SharedMemoryDataConsumerHandle::obtainReaderInternal(Client* client) {
   return new ReaderImpl(context_, client);
 }
 
 const char* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content