Update from chromium https://crrev.com/302282

cc/quads/list_container.cc

 // Copyright 2014 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 "cc/quads/list_container.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/base/scoped_ptr_vector.h"
@@ skipping 254 matching lines @@
 template <typename BaseElementType>
 ListContainer<BaseElementType>::~ListContainer() {
   for (Iterator i = begin(); i != end(); ++i) {
     i->~BaseElementType();
   }
 }
 
 template <typename BaseElementType>
 void ListContainer<BaseElementType>::EraseAndInvalidateAllPointers(
     typename ListContainer<BaseElementType>::Iterator position) {
-  BaseElementType* item = &*position;
+  BaseElementType* item = *position;
   item->~BaseElementType();
   data_->Erase(position);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstReverseIterator
 ListContainer<BaseElementType>::crbegin() const {
   if (data_->IsEmpty())
     return ConstReverseIterator(data_.get(), 0, NULL, 0);
 
@@ skipping 83 matching lines @@
   if (data_->IsEmpty())
     return Iterator(data_.get(), 0, NULL, size());
 
   size_t last_id = data_->list_count() - 1;
   return Iterator(data_.get(), last_id, NULL, size());
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::front() {
   Iterator iter = begin();
-  return &*iter;
+  return *iter;
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::back() {
   ReverseIterator iter = rbegin();
-  return &*iter;
+  return *iter;
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::front() const {
   ConstIterator iter = begin();
-  return &*iter;
+  return *iter;
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::back() const {
   ConstReverseIterator iter = rbegin();
-  return &*iter;
+  return *iter;
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ElementAt(
     size_t index) const {
   DCHECK_LT(index, size());
   size_t original_index = index;
   size_t list_index;
   for (list_index = 0; list_index < data_->list_count(); ++list_index) {
     size_t current_size = data_->InnerListById(list_index)->size;
     if (index < current_size)
       break;
     index -= current_size;
   }
-  return &*ConstIterator(data_.get(),
-                         list_index,
-                         data_->InnerListById(list_index)->ElementAt(index),
-                         original_index);
+  return *ConstIterator(data_.get(),
+                        list_index,
+                        data_->InnerListById(list_index)->ElementAt(index),
+                        original_index);
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::ElementAt(size_t index) {
   DCHECK_LT(index, size());
   size_t original_index = index;
   size_t list_index;
   for (list_index = 0; list_index < data_->list_count(); ++list_index) {
     size_t current_size = data_->InnerListById(list_index)->size;
     if (index < current_size)
       break;
     index -= current_size;
   }
-  return &*Iterator(data_.get(),
-                    list_index,
-                    data_->InnerListById(list_index)->ElementAt(index),
-                    original_index);
+  return *Iterator(data_.get(),
+                   list_index,
+                   data_->InnerListById(list_index)->ElementAt(index),
+                   original_index);
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::Allocate(
     size_t size_of_actual_element_in_bytes) {
   DCHECK_LE(size_of_actual_element_in_bytes, data_->element_size());
   void* result = data_->Allocate();
   return static_cast<BaseElementType*>(result);
 }
 
@@ skipping 36 matching lines @@
 template <typename BaseElementType>
 ListContainer<BaseElementType>::Iterator::~Iterator() {
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::Iterator::operator->() const {
   return reinterpret_cast<BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
-BaseElementType& ListContainer<BaseElementType>::Iterator::operator*() const {
-  return *(reinterpret_cast<BaseElementType*>(this->item_iterator));
+BaseElementType* ListContainer<BaseElementType>::Iterator::operator*() const {
+  return reinterpret_cast<BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::Iterator
 ListContainer<BaseElementType>::Iterator::
 operator++(int unused_post_increment) {
   Iterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
-typename ListContainer<BaseElementType>::Iterator
-ListContainer<BaseElementType>::Iterator::
-operator++() {
+typename ListContainer<BaseElementType>::Iterator&
+    ListContainer<BaseElementType>::Iterator::
+    operator++() {
   this->Increment();
   ++index_;
   return *this;
 }
 
 template <typename BaseElementType>
 size_t ListContainer<BaseElementType>::Iterator::index() const {
   return index_;
 }
 
@@ skipping 19 matching lines @@
 ListContainer<BaseElementType>::ConstIterator::~ConstIterator() {
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ConstIterator::
 operator->() const {
   return reinterpret_cast<const BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
-const BaseElementType& ListContainer<BaseElementType>::ConstIterator::
+const BaseElementType* ListContainer<BaseElementType>::ConstIterator::
 operator*() const {
-  return *(reinterpret_cast<const BaseElementType*>(this->item_iterator));
+  return reinterpret_cast<const BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstIterator
 ListContainer<BaseElementType>::ConstIterator::
 operator++(int unused_post_increment) {
   ConstIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
-typename ListContainer<BaseElementType>::ConstIterator
-ListContainer<BaseElementType>::ConstIterator::
-operator++() {
+typename ListContainer<BaseElementType>::ConstIterator&
+    ListContainer<BaseElementType>::ConstIterator::
+    operator++() {
   this->Increment();
   ++index_;
   return *this;
 }
 
 template <typename BaseElementType>
 size_t ListContainer<BaseElementType>::ConstIterator::index() const {
   return index_;
 }
 
@@ skipping 13 matching lines @@
 ListContainer<BaseElementType>::ReverseIterator::~ReverseIterator() {
 }
 
 template <typename BaseElementType>
 BaseElementType* ListContainer<BaseElementType>::ReverseIterator::operator->()
     const {
   return reinterpret_cast<BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
-BaseElementType& ListContainer<BaseElementType>::ReverseIterator::operator*()
+BaseElementType* ListContainer<BaseElementType>::ReverseIterator::operator*()
     const {
-  return *(reinterpret_cast<BaseElementType*>(this->item_iterator));
+  return reinterpret_cast<BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ReverseIterator
 ListContainer<BaseElementType>::ReverseIterator::
 operator++(int unused_post_increment) {
   ReverseIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
-typename ListContainer<BaseElementType>::ReverseIterator
-ListContainer<BaseElementType>::ReverseIterator::
-operator++() {
+typename ListContainer<BaseElementType>::ReverseIterator&
+    ListContainer<BaseElementType>::ReverseIterator::
+    operator++() {
   this->ReverseIncrement();
   ++index_;
   return *this;
 }
 
 template <typename BaseElementType>
 size_t ListContainer<BaseElementType>::ReverseIterator::index() const {
   return index_;
 }
 
@@ skipping 19 matching lines @@
 ListContainer<BaseElementType>::ConstReverseIterator::~ConstReverseIterator() {
 }
 
 template <typename BaseElementType>
 const BaseElementType* ListContainer<BaseElementType>::ConstReverseIterator::
 operator->() const {
   return reinterpret_cast<const BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
-const BaseElementType& ListContainer<BaseElementType>::ConstReverseIterator::
+const BaseElementType* ListContainer<BaseElementType>::ConstReverseIterator::
 operator*() const {
-  return *(reinterpret_cast<const BaseElementType*>(this->item_iterator));
+  return reinterpret_cast<const BaseElementType*>(this->item_iterator);
 }
 
 template <typename BaseElementType>
 typename ListContainer<BaseElementType>::ConstReverseIterator
 ListContainer<BaseElementType>::ConstReverseIterator::
 operator++(int unused_post_increment) {
   ConstReverseIterator tmp = *this;
   operator++();
   return tmp;
 }
 
 template <typename BaseElementType>
-typename ListContainer<BaseElementType>::ConstReverseIterator
-ListContainer<BaseElementType>::ConstReverseIterator::
-operator++() {
+typename ListContainer<BaseElementType>::ConstReverseIterator&
+    ListContainer<BaseElementType>::ConstReverseIterator::
+    operator++() {
   this->ReverseIncrement();
   ++index_;
   return *this;
 }
 
 template <typename BaseElementType>
 size_t ListContainer<BaseElementType>::ConstReverseIterator::index() const {
   return index_;
 }
 
 template class ListContainer<SharedQuadState>;
 template class ListContainer<DrawQuad>;
 
 }  // namespace cc