Remove implicit conversions from scoped_refptr to T* in cc/

cc/resources/prioritized_tile_set_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <vector>
 
 #include "cc/resources/managed_tile_state.h"
 #include "cc/resources/prioritized_tile_set.h"
 #include "cc/resources/tile.h"
@@ skipping 63 matching lines @@
                                      gfx::Rect(),
                                      1.0,
                                      0,
                                      0,
                                      0);
   }
   void ReleaseTiles(std::vector<scoped_refptr<Tile> >* tiles) {
     for (std::vector<scoped_refptr<Tile> >::iterator it = tiles->begin();
          it != tiles->end();
          it++) {
-      Tile* tile = *it;
+      Tile* tile = it->get();
       tile->SetPriority(ACTIVE_TREE, TilePriority());
       tile->SetPriority(PENDING_TREE, TilePriority());
     }
   }
 
  private:
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
@@ skipping 10 matching lines @@
 
   PrioritizedTileSet set;
 
   PrioritizedTileSet::Iterator it(&set, true);
   EXPECT_FALSE(it);
 }
 
 TEST_F(PrioritizedTileSetTest, NonEmptyIterator) {
   PrioritizedTileSet set;
   scoped_refptr<Tile> tile = CreateTile();
-  set.InsertTile(tile, NOW_BIN);
+  set.InsertTile(tile.get(), NOW_BIN);
 
   PrioritizedTileSet::Iterator it(&set, true);
   EXPECT_TRUE(it);
   EXPECT_TRUE(*it == tile.get());
   ++it;
   EXPECT_FALSE(it);
 }
 
 TEST_F(PrioritizedTileSetTest, NowAndReadyToDrawBin) {
   // Ensure that tiles in NOW_AND_READY_TO_DRAW_BIN aren't sorted.
 
   PrioritizedTileSet set;
   TilePriority priorities[4] = {
       TilePriorityForEventualBin(),
       TilePriorityForNowBin(),
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
+      set.InsertTile(tile.get(), NOW_AND_READY_TO_DRAW_BIN);
     }
   }
 
   // Tiles should appear in the same order as inserted.
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
@@ skipping 13 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, NOW_BIN);
+      set.InsertTile(tile.get(), NOW_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 15 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, SOON_BIN);
+      set.InsertTile(tile.get(), SOON_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 16 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, SOON_BIN);
+      set.InsertTile(tile.get(), SOON_BIN);
     }
   }
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, false);
        it;
        ++it) {
     EXPECT_TRUE(*it == tiles[i].get());
     ++i;
   }
@@ skipping 12 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_AND_ACTIVE_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 15 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, EVENTUALLY_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 15 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), AT_LAST_AND_ACTIVE_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 15 matching lines @@
       TilePriority(),
       TilePriorityForSoonBin()};
 
   std::vector<scoped_refptr<Tile> > tiles;
   for (int priority = 0; priority < 4; ++priority) {
     for (int i = 0; i < 5; ++i) {
       scoped_refptr<Tile> tile = CreateTile();
       tile->SetPriority(ACTIVE_TREE, priorities[priority]);
       tile->SetPriority(PENDING_TREE, priorities[priority]);
       tiles.push_back(tile);
-      set.InsertTile(tile, AT_LAST_BIN);
+      set.InsertTile(tile.get(), AT_LAST_BIN);
     }
   }
 
   // Tiles should appear in BinComparator order.
   std::sort(tiles.begin(), tiles.end(), BinComparator());
 
   int i = 0;
   for (PrioritizedTileSet::Iterator it(&set, true);
        it;
        ++it) {
@@ skipping 11 matching lines @@
 
   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
   scoped_refptr<Tile> now_bin = CreateTile();
   scoped_refptr<Tile> soon_bin = CreateTile();
   scoped_refptr<Tile> eventually_and_active_bin = CreateTile();
   scoped_refptr<Tile> eventually_bin = CreateTile();
   scoped_refptr<Tile> at_last_bin = CreateTile();
   scoped_refptr<Tile> at_last_and_active_bin = CreateTile();
 
   PrioritizedTileSet set;
-  set.InsertTile(soon_bin, SOON_BIN);
-  set.InsertTile(at_last_and_active_bin, AT_LAST_AND_ACTIVE_BIN);
-  set.InsertTile(eventually_bin, EVENTUALLY_BIN);
-  set.InsertTile(now_bin, NOW_BIN);
-  set.InsertTile(eventually_and_active_bin, EVENTUALLY_AND_ACTIVE_BIN);
-  set.InsertTile(at_last_bin, AT_LAST_BIN);
-  set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
+  set.InsertTile(soon_bin.get(), SOON_BIN);
+  set.InsertTile(at_last_and_active_bin.get(), AT_LAST_AND_ACTIVE_BIN);
+  set.InsertTile(eventually_bin.get(), EVENTUALLY_BIN);
+  set.InsertTile(now_bin.get(), NOW_BIN);
+  set.InsertTile(eventually_and_active_bin.get(), EVENTUALLY_AND_ACTIVE_BIN);
+  set.InsertTile(at_last_bin.get(), AT_LAST_BIN);
+  set.InsertTile(now_and_ready_to_draw_bin.get(), NOW_AND_READY_TO_DRAW_BIN);
 
   // Tiles should appear in order.
   PrioritizedTileSet::Iterator it(&set, true);
   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
   ++it;
   EXPECT_TRUE(*it == now_bin.get());
   ++it;
   EXPECT_TRUE(*it == soon_bin.get());
   ++it;
   EXPECT_TRUE(*it == eventually_and_active_bin.get());
@@ skipping 33 matching lines @@
       tile->SetPriority(PENDING_TREE, priorities[priority]);
 
       now_and_ready_to_draw_bins.push_back(tile);
       now_bins.push_back(tile);
       soon_bins.push_back(tile);
       eventually_and_active_bins.push_back(tile);
       eventually_bins.push_back(tile);
       at_last_bins.push_back(tile);
       at_last_and_active_bins.push_back(tile);
 
-      set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
-      set.InsertTile(tile, NOW_BIN);
-      set.InsertTile(tile, SOON_BIN);
-      set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
-      set.InsertTile(tile, EVENTUALLY_BIN);
-      set.InsertTile(tile, AT_LAST_BIN);
-      set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), NOW_AND_READY_TO_DRAW_BIN);
+      set.InsertTile(tile.get(), NOW_BIN);
+      set.InsertTile(tile.get(), SOON_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_BIN);
+      set.InsertTile(tile.get(), AT_LAST_BIN);
+      set.InsertTile(tile.get(), AT_LAST_AND_ACTIVE_BIN);
     }
   }
 
   PrioritizedTileSet::Iterator it(&set, true);
   std::vector<scoped_refptr<Tile> >::iterator vector_it;
 
   // Now and ready are not sorted.
   for (vector_it = now_and_ready_to_draw_bins.begin();
        vector_it != now_and_ready_to_draw_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Now bins are sorted.
   std::sort(now_bins.begin(), now_bins.end(), BinComparator());
   for (vector_it = now_bins.begin(); vector_it != now_bins.end(); ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Soon bins are sorted.
   std::sort(soon_bins.begin(), soon_bins.end(), BinComparator());
   for (vector_it = soon_bins.begin(); vector_it != soon_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Eventually and active bins are sorted.
   std::sort(eventually_and_active_bins.begin(),
             eventually_and_active_bins.end(),
             BinComparator());
   for (vector_it = eventually_and_active_bins.begin();
        vector_it != eventually_and_active_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Eventually bins are sorted.
   std::sort(eventually_bins.begin(), eventually_bins.end(), BinComparator());
   for (vector_it = eventually_bins.begin(); vector_it != eventually_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // At last and active bins are sorted.
   std::sort(at_last_and_active_bins.begin(),
             at_last_and_active_bins.end(),
             BinComparator());
   for (vector_it = at_last_and_active_bins.begin();
        vector_it != at_last_and_active_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // At last bins are sorted.
   std::sort(at_last_bins.begin(), at_last_bins.end(), BinComparator());
   for (vector_it = at_last_bins.begin(); vector_it != at_last_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   EXPECT_FALSE(it);
 
   ReleaseTiles(&now_and_ready_to_draw_bins);
   ReleaseTiles(&now_bins);
   ReleaseTiles(&soon_bins);
   ReleaseTiles(&eventually_and_active_bins);
   ReleaseTiles(&eventually_bins);
@@ skipping 28 matching lines @@
       tile->SetPriority(PENDING_TREE, priorities[priority]);
 
       now_and_ready_to_draw_bins.push_back(tile);
       now_bins.push_back(tile);
       soon_bins.push_back(tile);
       eventually_and_active_bins.push_back(tile);
       eventually_bins.push_back(tile);
       at_last_bins.push_back(tile);
       at_last_and_active_bins.push_back(tile);
 
-      set.InsertTile(tile, NOW_AND_READY_TO_DRAW_BIN);
-      set.InsertTile(tile, NOW_BIN);
-      set.InsertTile(tile, SOON_BIN);
-      set.InsertTile(tile, EVENTUALLY_AND_ACTIVE_BIN);
-      set.InsertTile(tile, EVENTUALLY_BIN);
-      set.InsertTile(tile, AT_LAST_BIN);
-      set.InsertTile(tile, AT_LAST_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), NOW_AND_READY_TO_DRAW_BIN);
+      set.InsertTile(tile.get(), NOW_BIN);
+      set.InsertTile(tile.get(), SOON_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_AND_ACTIVE_BIN);
+      set.InsertTile(tile.get(), EVENTUALLY_BIN);
+      set.InsertTile(tile.get(), AT_LAST_BIN);
+      set.InsertTile(tile.get(), AT_LAST_AND_ACTIVE_BIN);
     }
   }
 
   PrioritizedTileSet::Iterator it(&set, true);
   std::vector<scoped_refptr<Tile> >::iterator vector_it;
 
   // Now and ready are not sorted.
   for (vector_it = now_and_ready_to_draw_bins.begin();
        vector_it != now_and_ready_to_draw_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Now bins are sorted.
   std::sort(now_bins.begin(), now_bins.end(), BinComparator());
   for (vector_it = now_bins.begin(); vector_it != now_bins.end(); ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Soon bins are sorted.
   std::sort(soon_bins.begin(), soon_bins.end(), BinComparator());
   for (vector_it = soon_bins.begin(); vector_it != soon_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // After we disable priority ordering, we already have sorted the next vector.
   it.DisablePriorityOrdering();
 
   // Eventually and active bins are sorted.
   std::sort(eventually_and_active_bins.begin(),
             eventually_and_active_bins.end(),
             BinComparator());
   for (vector_it = eventually_and_active_bins.begin();
        vector_it != eventually_and_active_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // Eventually bins are not sorted.
   for (vector_it = eventually_bins.begin(); vector_it != eventually_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // At last and active bins are not sorted.
   for (vector_it = at_last_and_active_bins.begin();
        vector_it != at_last_and_active_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   // At last bins are not sorted.
   for (vector_it = at_last_bins.begin(); vector_it != at_last_bins.end();
        ++vector_it) {
-    EXPECT_TRUE(*vector_it == *it);
+    EXPECT_TRUE(vector_it->get() == *it);
     ++it;
   }
 
   EXPECT_FALSE(it);
 
   ReleaseTiles(&now_and_ready_to_draw_bins);
   ReleaseTiles(&now_bins);
   ReleaseTiles(&soon_bins);
   ReleaseTiles(&eventually_and_active_bins);
   ReleaseTiles(&eventually_bins);
   ReleaseTiles(&at_last_bins);
   ReleaseTiles(&at_last_and_active_bins);
 }
 
 TEST_F(PrioritizedTileSetTest, TilesForFirstAndLastBins) {
   // Make sure that if we have empty lists between two non-empty lists,
   // we just get two tiles from the iterator.
 
   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
   scoped_refptr<Tile> at_last_bin = CreateTile();
 
   PrioritizedTileSet set;
-  set.InsertTile(at_last_bin, AT_LAST_BIN);
-  set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
+  set.InsertTile(at_last_bin.get(), AT_LAST_BIN);
+  set.InsertTile(now_and_ready_to_draw_bin.get(), NOW_AND_READY_TO_DRAW_BIN);
 
   // Only two tiles should appear and they should appear in order.
   PrioritizedTileSet::Iterator it(&set, true);
   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
   ++it;
   EXPECT_TRUE(*it == at_last_bin.get());
   ++it;
   EXPECT_FALSE(it);
 }
 
 TEST_F(PrioritizedTileSetTest, MultipleIterators) {
   // Ensure that multiple iterators don't interfere with each other.
 
   scoped_refptr<Tile> now_and_ready_to_draw_bin = CreateTile();
   scoped_refptr<Tile> now_bin = CreateTile();
   scoped_refptr<Tile> soon_bin = CreateTile();
   scoped_refptr<Tile> eventually_bin = CreateTile();
   scoped_refptr<Tile> at_last_bin = CreateTile();
 
   PrioritizedTileSet set;
-  set.InsertTile(soon_bin, SOON_BIN);
-  set.InsertTile(eventually_bin, EVENTUALLY_BIN);
-  set.InsertTile(now_bin, NOW_BIN);
-  set.InsertTile(at_last_bin, AT_LAST_BIN);
-  set.InsertTile(now_and_ready_to_draw_bin, NOW_AND_READY_TO_DRAW_BIN);
+  set.InsertTile(soon_bin.get(), SOON_BIN);
+  set.InsertTile(eventually_bin.get(), EVENTUALLY_BIN);
+  set.InsertTile(now_bin.get(), NOW_BIN);
+  set.InsertTile(at_last_bin.get(), AT_LAST_BIN);
+  set.InsertTile(now_and_ready_to_draw_bin.get(), NOW_AND_READY_TO_DRAW_BIN);
 
   // Tiles should appear in order.
   PrioritizedTileSet::Iterator it(&set, true);
   EXPECT_TRUE(*it == now_and_ready_to_draw_bin.get());
   ++it;
   EXPECT_TRUE(*it == now_bin.get());
   ++it;
   EXPECT_TRUE(*it == soon_bin.get());
   ++it;
   EXPECT_TRUE(*it == eventually_bin.get());
@@ skipping 36 matching lines @@
 
   set.Clear();
 
   PrioritizedTileSet::Iterator empty_it(&set, true);
   EXPECT_FALSE(empty_it);
 }
 
 }  // namespace
 }  // namespace cc