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

cc/quads/list_container_unittest.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 <vector>
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 212 matching lines @@
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<SharedQuadState>::Iterator iter = list.begin();
   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
            sqs_list.begin();
        sqs_iter != sqs_list.end();
        ++sqs_iter) {
-    EXPECT_EQ(*sqs_iter, &*iter);
+    EXPECT_EQ(*sqs_iter, *iter);
     ++iter;
   }
 }
 
 TEST(ListContainerTest,
      CorrectAllocationSizeForMoreThanOneAllocationSharedQuadState) {
   // Constructor sets the allocation size to 2. Every time ListContainer needs
   // to allocate again, it doubles allocation size. In this test, 10 elements is
   // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements.
   ListContainer<SharedQuadState> list(sizeof(SharedQuadState), 2);
@@ skipping 64 matching lines @@
         break;
     }
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<SharedQuadState>::Iterator iter = list.begin();
   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
            sqs_list.begin();
        sqs_iter != sqs_list.end();
        ++sqs_iter) {
-    EXPECT_EQ(*sqs_iter, &*iter);
+    EXPECT_EQ(*sqs_iter, *iter);
     ++iter;
   }
 }
 
 TEST(ListContainerTest, SimpleIterationSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   size_t num_iters_in_list = 0;
   {
     std::vector<SharedQuadState*>::const_iterator sqs_iter = sqs_list.begin();
     for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
          iter != list.end();
          ++iter) {
-      EXPECT_EQ(*sqs_iter, &*iter);
+      EXPECT_EQ(*sqs_iter, *iter);
       ++num_iters_in_list;
       ++sqs_iter;
     }
   }
 
   size_t num_iters_in_vector = 0;
   {
     ListContainer<SharedQuadState>::Iterator iter = list.begin();
     for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
              sqs_list.begin();
          sqs_iter != sqs_list.end();
          ++sqs_iter) {
-      EXPECT_EQ(*sqs_iter, &*iter);
+      EXPECT_EQ(*sqs_iter, *iter);
       ++num_iters_in_vector;
       ++iter;
     }
   }
 
   EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
 }
 
 TEST(ListContainerTest, SimpleConstIteratorIterationSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<const SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<const SharedQuadState*>::const_iterator sqs_iter =
         sqs_list.begin();
     for (ListContainer<SharedQuadState>::ConstIterator iter = list.begin();
          iter != list.end();
          ++iter) {
-      EXPECT_TRUE(isConstSharedQuadStatePointer(&*iter));
-      EXPECT_EQ(*sqs_iter, &*iter);
+      EXPECT_TRUE(isConstSharedQuadStatePointer(*iter));
+      EXPECT_EQ(*sqs_iter, *iter);
       ++sqs_iter;
     }
   }
 
   {
     std::vector<const SharedQuadState*>::const_iterator sqs_iter =
         sqs_list.begin();
     for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
          iter != list.end();
          ++iter) {
-      EXPECT_FALSE(isConstSharedQuadStatePointer(&*iter));
-      EXPECT_EQ(*sqs_iter, &*iter);
+      EXPECT_FALSE(isConstSharedQuadStatePointer(*iter));
+      EXPECT_EQ(*sqs_iter, *iter);
       ++sqs_iter;
     }
   }
 
   {
     ListContainer<SharedQuadState>::ConstIterator iter = list.begin();
     for (std::vector<const SharedQuadState*>::const_iterator sqs_iter =
              sqs_list.begin();
          sqs_iter != sqs_list.end();
          ++sqs_iter) {
-      EXPECT_EQ(*sqs_iter, &*iter);
+      EXPECT_EQ(*sqs_iter, *iter);
       ++iter;
     }
   }
 }
 
 TEST(ListContainerTest, SimpleReverseInsertionSharedQuadState) {
   ListContainer<SharedQuadState> list;
   std::vector<SharedQuadState*> sqs_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<SharedQuadState*>::const_reverse_iterator sqs_iter =
         sqs_list.rbegin();
     for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
          iter != list.rend();
          ++iter) {
-      EXPECT_EQ(*sqs_iter, &(*iter));
+      EXPECT_EQ(*sqs_iter, *iter);
       ++sqs_iter;
     }
   }
 
   {
     ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
     for (std::vector<SharedQuadState*>::reverse_iterator sqs_iter =
              sqs_list.rbegin();
          sqs_iter != sqs_list.rend();
          ++sqs_iter) {
-      EXPECT_EQ(*sqs_iter, &(*iter));
+      EXPECT_EQ(*sqs_iter, *iter);
       ++iter;
     }
   }
 }
 
 TEST(ListContainerTest, SimpleDeletion) {
   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
   std::vector<SimpleDrawQuad*> sdq_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     sdq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
     sdq_list.back()->set_value(i);
   }
   EXPECT_EQ(size, list.size());
 
   list.EraseAndInvalidateAllPointers(list.begin());
   --size;
   EXPECT_EQ(size, list.size());
   int i = 1;
   for (ListContainer<DrawQuad>::Iterator iter = list.begin();
        iter != list.end();
        ++iter) {
-    EXPECT_EQ(i, static_cast<SimpleDrawQuad*>(&*iter)->get_value());
+    EXPECT_EQ(i, static_cast<SimpleDrawQuad*>(*iter)->get_value());
     ++i;
   }
 }
 
 TEST(ListContainerTest, SimpleIterationAndManipulation) {
   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
   std::vector<SimpleDrawQuad*> sdq_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     SimpleDrawQuad* simple_dq = list.AllocateAndConstruct<SimpleDrawQuad>();
     sdq_list.push_back(simple_dq);
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<DrawQuad>::Iterator iter = list.begin();
   for (int i = 0; i < 10; ++i) {
-    static_cast<SimpleDrawQuad*>(&*iter)->set_value(i);
+    static_cast<SimpleDrawQuad*>(*iter)->set_value(i);
     ++iter;
   }
 
   int i = 0;
   for (std::vector<SimpleDrawQuad*>::const_iterator sdq_iter = sdq_list.begin();
        sdq_iter < sdq_list.end();
        ++sdq_iter) {
     EXPECT_EQ(i, (*sdq_iter)->get_value());
     ++i;
   }
@@ skipping 64 matching lines @@
   for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
        iter != list.rend();
        ++iter) {
     EXPECT_EQ(i, iter.index());
     ++i;
   }
 }
 
 }  // namespace
 }  // namespace cc