cc: Replace > > with >>

R=enne

Review URL: https://codereview.chromium.org/662473003

Cr-Commit-Position: refs/heads/master@{#299809}

32 files changed, 75 insertions, 60 deletions

diff --git a/cc/PRESUBMIT.py b/cc/PRESUBMIT.py
index 255d5ff..1aa48f3 100644
--- a/cc/PRESUBMIT.py
+++ b/cc/PRESUBMIT.py
@@ -150,6 +150,22 @@ def CheckTodos(input_api, output_api):
       items=errors)]
   return []
 
+def CheckDoubleAngles(input_api, output_api, white_list=CC_SOURCE_FILES,
+                      black_list=None):
+  errors = []
+
+  source_file_filter = lambda x: input_api.FilterSourceFile(x,
+                                                            white_list,
+                                                            black_list)
+  for f in input_api.AffectedSourceFiles(source_file_filter):
+    contents = input_api.ReadFile(f, 'rb')
+    if ('> >') in contents:
+      errors.append(f.LocalPath())
+
+  if errors:
+    return [output_api.PresubmitError('Use >> instead of > >:', items=errors)]
+  return []
+
 def CheckScopedPtr(input_api, output_api,
                    white_list=CC_SOURCE_FILES, black_list=None):
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
@@ -359,6 +375,7 @@ def CheckChangeOnUpload(input_api, output_api):
   results += CheckPassByValue(input_api, output_api)
   results += CheckChangeLintsClean(input_api, output_api)
   results += CheckTodos(input_api, output_api)
+  results += CheckDoubleAngles(input_api, output_api)
   results += CheckScopedPtr(input_api, output_api)
   results += CheckNamespace(input_api, output_api)
   results += CheckForUseOfWrongClock(input_api, output_api)
diff --git a/cc/base/tiling_data_unittest.cc b/cc/base/tiling_data_unittest.cc
index 9c2f944..855cd2a 100644
--- a/cc/base/tiling_data_unittest.cc
+++ b/cc/base/tiling_data_unittest.cc
@@ -1038,7 +1038,7 @@ void TestIterate(const TilingData& data,
   EXPECT_LT(expect_right, data.num_tiles_x());
   EXPECT_LT(expect_bottom, data.num_tiles_y());
 
-  std::vector<std::pair<int, int> > original_expected;
+  std::vector<std::pair<int, int>> original_expected;
   for (int x = 0; x < data.num_tiles_x(); ++x) {
     for (int y = 0; y < data.num_tiles_y(); ++y) {
       gfx::Rect bounds;
@@ -1058,7 +1058,7 @@ void TestIterate(const TilingData& data,
 
   // Verify with vanilla iterator.
   {
-    std::vector<std::pair<int, int> > expected = original_expected;
+    std::vector<std::pair<int, int>> expected = original_expected;
     for (TilingData::Iterator iter(&data, rect, include_borders); iter;
          ++iter) {
       bool found = false;
@@ -1078,7 +1078,7 @@ void TestIterate(const TilingData& data,
   // Make sure this also works with a difference iterator and an empty ignore.
   // The difference iterator never includes borders, so ignore it otherwise.
   if (!include_borders) {
-    std::vector<std::pair<int, int> > expected = original_expected;
+    std::vector<std::pair<int, int>> expected = original_expected;
     for (TilingData::DifferenceIterator iter(&data, rect, gfx::Rect()); iter;
          ++iter) {
       bool found = false;
@@ -1244,7 +1244,7 @@ void TestDiff(const TilingData& data,
               gfx::Rect consider,
               gfx::Rect ignore,
               size_t num_tiles) {
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   for (int y = 0; y < data.num_tiles_y(); ++y) {
     for (int x = 0; x < data.num_tiles_x(); ++x) {
       gfx::Rect bounds = data.TileBounds(x, y);
@@ -1373,8 +1373,8 @@ void TestSpiralIterate(int source_line_number,
                        const gfx::Rect& consider,
                        const gfx::Rect& ignore,
                        const gfx::Rect& center,
-                       const std::vector<std::pair<int, int> >& expected) {
-  std::vector<std::pair<int, int> > actual;
+                       const std::vector<std::pair<int, int>>& expected) {
+  std::vector<std::pair<int, int>> actual;
   for (TilingData::SpiralDifferenceIterator it(
            &tiling_data, consider, ignore, center);
        it;
@@ -1396,7 +1396,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
   gfx::Rect consider(30, 30);
   gfx::Rect ignore;
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
 
   // Center is in the center of the tiling.
   gfx::Rect center(15, 15, 1, 1);
@@ -1507,7 +1507,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
 TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect ignore;
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center(15, 15, 1, 1);
 
   // Consider is one cell.
@@ -1567,7 +1567,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
 TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect consider(50, 50);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center(15, 15, 1, 1);
 
   // Full ignore.
@@ -1641,7 +1641,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
 TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect consider(50, 50);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect ignore;
 
   // Two cell center
@@ -1762,7 +1762,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
 
 TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center;
   gfx::Rect consider;
   gfx::Rect ignore;
diff --git a/cc/debug/picture_record_benchmark.h b/cc/debug/picture_record_benchmark.h
index 42404b1..472f660 100644
--- a/cc/debug/picture_record_benchmark.h
+++ b/cc/debug/picture_record_benchmark.h
@@ -31,7 +31,7 @@ class CC_EXPORT PictureRecordBenchmark : public MicroBenchmark {
 
   typedef std::pair<base::TimeDelta, unsigned> TotalTime;
   std::map<std::pair<int, int>, TotalTime> times_;
-  std::vector<std::pair<int, int> > dimensions_;
+  std::vector<std::pair<int, int>> dimensions_;
 };
 
 }  // namespace cc
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index dd41669..5af7195 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -618,10 +618,10 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   FilterOperations background_filters_;
   LayerPositionConstraint position_constraint_;
   Layer* scroll_parent_;
-  scoped_ptr<std::set<Layer*> > scroll_children_;
+  scoped_ptr<std::set<Layer*>> scroll_children_;
 
   Layer* clip_parent_;
-  scoped_ptr<std::set<Layer*> > clip_children_;
+  scoped_ptr<std::set<Layer*>> clip_children_;
 
   gfx::Transform transform_;
   gfx::Point3F transform_origin_;
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 76427a1..7e51eed 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -601,10 +601,10 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   // used. If this pointer turns out to be too heavy, we could have this (and
   // the scroll parent above) be stored in a LayerImpl -> scroll_info
   // map somewhere.
-  scoped_ptr<std::set<LayerImpl*> > scroll_children_;
+  scoped_ptr<std::set<LayerImpl*>> scroll_children_;
 
   LayerImpl* clip_parent_;
-  scoped_ptr<std::set<LayerImpl*> > clip_children_;
+  scoped_ptr<std::set<LayerImpl*>> clip_children_;
 
   // mask_layer_ can be temporarily stolen during tree sync, we need this ID to
   // confirm newly assigned layer is still the previous one
diff --git a/cc/layers/layer_lists.h b/cc/layers/layer_lists.h
index c0f7bbf..9a4084b 100644
--- a/cc/layers/layer_lists.h
+++ b/cc/layers/layer_lists.h
@@ -15,7 +15,7 @@ namespace cc {
 class Layer;
 class LayerImpl;
 
-typedef std::vector<scoped_refptr<Layer> > LayerList;
+typedef std::vector<scoped_refptr<Layer>> LayerList;
 
 typedef ScopedPtrVector<LayerImpl> OwnedLayerImplList;
 typedef std::vector<LayerImpl*> LayerImplList;
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index e32a6e7eb..bd832be 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -133,7 +133,7 @@ class LayerTest : public testing::Test {
   FakeLayerTreeHostImpl host_impl_;
 
   FakeLayerTreeHostClient fake_client_;
-  scoped_ptr<StrictMock<MockLayerTreeHost> > layer_tree_host_;
+  scoped_ptr<StrictMock<MockLayerTreeHost>> layer_tree_host_;
   scoped_refptr<Layer> parent_;
   scoped_refptr<Layer> child1_;
   scoped_refptr<Layer> child2_;
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 3b60edd..a12b1d2 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -182,8 +182,8 @@ class CC_EXPORT PictureLayerTiling {
       UpdateTileAndTwinPriority(it->second.get());
   }
 
-  std::vector<scoped_refptr<Tile> > AllRefTilesForTesting() const {
-    std::vector<scoped_refptr<Tile> > all_tiles;
+  std::vector<scoped_refptr<Tile>> AllRefTilesForTesting() const {
+    std::vector<scoped_refptr<Tile>> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       all_tiles.push_back(it->second);
     return all_tiles;
@@ -296,7 +296,7 @@ class CC_EXPORT PictureLayerTiling {
   friend class TilingEvictionTileIterator;
 
   typedef std::pair<int, int> TileMapKey;
-  typedef base::hash_map<TileMapKey, scoped_refptr<Tile> > TileMap;
+  typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 
   PictureLayerTiling(float contents_scale,
                      const gfx::Size& layer_bounds,
diff --git a/cc/resources/picture_layer_tiling_set_unittest.cc b/cc/resources/picture_layer_tiling_set_unittest.cc
index f8cba03..f4059e4 100644
--- a/cc/resources/picture_layer_tiling_set_unittest.cc
+++ b/cc/resources/picture_layer_tiling_set_unittest.cc
@@ -515,7 +515,7 @@ TEST_F(PictureLayerTilingSetSyncTest, Invalidation) {
   }
 
   std::vector<Tile*> old_tiles = target_->tiling_at(0)->AllTilesForTesting();
-  std::map<gfx::Point, scoped_refptr<Tile> > old_tile_map;
+  std::map<gfx::Point, scoped_refptr<Tile>> old_tile_map;
   for (size_t i = 0; i < old_tiles.size(); ++i)
     old_tile_map[old_tiles[i]->content_rect().origin()] = old_tiles[i];
 
@@ -525,7 +525,7 @@ TEST_F(PictureLayerTilingSetSyncTest, Invalidation) {
   std::vector<Tile*> new_tiles = target_->tiling_at(0)->AllTilesForTesting();
   for (size_t i = 0; i < new_tiles.size(); ++i) {
     const Tile* tile = new_tiles[i];
-    std::map<gfx::Point, scoped_refptr<Tile> >::iterator find =
+    std::map<gfx::Point, scoped_refptr<Tile>>::iterator find =
         old_tile_map.find(tile->content_rect().origin());
     if (content_invalidation.Intersects(tile->content_rect()))
       EXPECT_NE(tile, find->second.get());
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.h b/cc/resources/pixel_buffer_raster_worker_pool.h
index 65fcdad..78933aa 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.h
+++ b/cc/resources/pixel_buffer_raster_worker_pool.h
@@ -75,7 +75,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool : public RasterWorkerPool,
     TaskSetCollection task_sets;
   };
 
-  typedef std::deque<scoped_refptr<RasterTask> > RasterTaskDeque;
+  typedef std::deque<scoped_refptr<RasterTask>> RasterTaskDeque;
 
   PixelBufferRasterWorkerPool(base::SequencedTaskRunner* task_runner,
                               TaskGraphRunner* task_graph_runner,
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index b491e9b..c4e43ac 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -165,7 +165,7 @@ class PerfRasterTaskImpl : public RasterTask {
 
 class RasterWorkerPoolPerfTestBase {
  public:
-  typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
+  typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION = 0, ALL = 1 };
 
diff --git a/cc/resources/raster_worker_pool_unittest.cc b/cc/resources/raster_worker_pool_unittest.cc
index e652cd6..7e3d1f9 100644
--- a/cc/resources/raster_worker_pool_unittest.cc
+++ b/cc/resources/raster_worker_pool_unittest.cc
@@ -120,7 +120,7 @@ class RasterWorkerPoolTest
     bool canceled;
   };
 
-  typedef std::vector<scoped_refptr<RasterTask> > RasterTaskVector;
+  typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION = 0, ALL = 1 };
 
diff --git a/cc/resources/rasterizer.h b/cc/resources/rasterizer.h
index 5d2eeee..8013593 100644
--- a/cc/resources/rasterizer.h
+++ b/cc/resources/rasterizer.h
@@ -30,7 +30,7 @@ class CC_EXPORT RasterizerTaskClient {
 
 class CC_EXPORT RasterizerTask : public Task {
  public:
-  typedef std::vector<scoped_refptr<RasterizerTask> > Vector;
+  typedef std::vector<scoped_refptr<RasterizerTask>> Vector;
 
   virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) = 0;
   virtual void CompleteOnOriginThread(RasterizerTaskClient* client) = 0;
@@ -58,7 +58,7 @@ class CC_EXPORT RasterizerTask : public Task {
 
 class CC_EXPORT ImageDecodeTask : public RasterizerTask {
  public:
-  typedef std::vector<scoped_refptr<ImageDecodeTask> > Vector;
+  typedef std::vector<scoped_refptr<ImageDecodeTask>> Vector;
 
   // Overridden from RasterizerTask:
   virtual ImageDecodeTask* AsImageDecodeTask() override;
@@ -70,7 +70,7 @@ class CC_EXPORT ImageDecodeTask : public RasterizerTask {
 
 class CC_EXPORT RasterTask : public RasterizerTask {
  public:
-  typedef std::vector<scoped_refptr<RasterTask> > Vector;
+  typedef std::vector<scoped_refptr<RasterTask>> Vector;
 
   // Overridden from RasterizerTask:
   virtual RasterTask* AsRasterTask() override;
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index ded3477..578c2e9 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -1440,7 +1440,7 @@ void ResourceProvider::ReceiveReturnsFromParent(
   int child_id = 0;
   ResourceIdArray resources_for_child;
 
-  std::vector<std::pair<ReturnedResource, ResourceMap::iterator> >
+  std::vector<std::pair<ReturnedResource, ResourceMap::iterator>>
       sorted_resources;
 
   for (ReturnedResourceArray::const_iterator it = resources.begin();
diff --git a/cc/resources/resource_provider_unittest.cc b/cc/resources/resource_provider_unittest.cc
index 25ca028..3daef66 100644
--- a/cc/resources/resource_provider_unittest.cc
+++ b/cc/resources/resource_provider_unittest.cc
@@ -158,7 +158,7 @@ class ContextSharedData {
 
   uint32 next_sync_point_;
   unsigned next_mailbox_;
-  typedef base::hash_map<unsigned, scoped_refptr<TestTexture> > TextureMap;
+  typedef base::hash_map<unsigned, scoped_refptr<TestTexture>> TextureMap;
   TextureMap textures_;
   base::hash_map<unsigned, uint32> sync_point_for_mailbox_;
 };
diff --git a/cc/resources/task_graph_runner.h b/cc/resources/task_graph_runner.h
index 0ed7140..2ff085d 100644
--- a/cc/resources/task_graph_runner.h
+++ b/cc/resources/task_graph_runner.h
@@ -17,7 +17,7 @@ namespace cc {
 
 class CC_EXPORT Task : public base::RefCountedThreadSafe<Task> {
  public:
-  typedef std::vector<scoped_refptr<Task> > Vector;
+  typedef std::vector<scoped_refptr<Task>> Vector;
 
   virtual void RunOnWorkerThread() = 0;
 
diff --git a/cc/resources/task_graph_runner_perftest.cc b/cc/resources/task_graph_runner_perftest.cc
index 999043f..2ce6dc8 100644
--- a/cc/resources/task_graph_runner_perftest.cc
+++ b/cc/resources/task_graph_runner_perftest.cc
@@ -22,7 +22,7 @@ static const int kTimeCheckInterval = 10;
 
 class PerfTaskImpl : public Task {
  public:
-  typedef std::vector<scoped_refptr<PerfTaskImpl> > Vector;
+  typedef std::vector<scoped_refptr<PerfTaskImpl>> Vector;
 
   PerfTaskImpl() {}
 
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 94f1033..03fb6e1 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -249,7 +249,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
   bool did_oom_on_last_assign_;
 
-  typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> >
+  typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>
       PixelRefTaskMap;
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
@@ -266,7 +266,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   // Queue used when scheduling raster tasks.
   RasterTaskQueue raster_queue_;
 
-  std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
+  std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
 
   UniqueNotifier ready_to_activate_check_notifier_;
 
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index add50ca..e69e0c4 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -256,7 +256,7 @@ class FakeSchedulerClient : public SchedulerClient {
   bool redraw_will_happen_if_update_visible_tiles_happens_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
-  std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat> > states_;
+  std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat>> states_;
   scoped_ptr<TestScheduler> scheduler_;
   scoped_refptr<TestNowSource> now_src_;
   FakeBeginFrameSourceForFakeSchedulerClient fake_frame_source_;
diff --git a/cc/test/fake_content_layer_client.h b/cc/test/fake_content_layer_client.h
index 3ae031a..b74860d 100644
--- a/cc/test/fake_content_layer_client.h
+++ b/cc/test/fake_content_layer_client.h
@@ -59,7 +59,7 @@ class FakeContentLayerClient : public ContentLayerClient {
   }
 
  private:
-  typedef std::vector<std::pair<gfx::RectF, SkPaint> > RectPaintVector;
+  typedef std::vector<std::pair<gfx::RectF, SkPaint>> RectPaintVector;
   typedef std::vector<BitmapData> BitmapVector;
 
   bool fill_with_nonsolid_color_;
diff --git a/cc/test/fake_painted_scrollbar_layer.cc b/cc/test/fake_painted_scrollbar_layer.cc
index 88dd010..e74581a 100644
--- a/cc/test/fake_painted_scrollbar_layer.cc
+++ b/cc/test/fake_painted_scrollbar_layer.cc
@@ -47,7 +47,7 @@ void FakePaintedScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   ++push_properties_count_;
 }
 
-scoped_ptr<base::AutoReset<bool> >
+scoped_ptr<base::AutoReset<bool>>
 FakePaintedScrollbarLayer::IgnoreSetNeedsCommit() {
   return make_scoped_ptr(
       new base::AutoReset<bool>(&ignore_set_needs_commit_, true));
diff --git a/cc/test/fake_painted_scrollbar_layer.h b/cc/test/fake_painted_scrollbar_layer.h
index f531299..0fb3437 100644
--- a/cc/test/fake_painted_scrollbar_layer.h
+++ b/cc/test/fake_painted_scrollbar_layer.h
@@ -25,7 +25,7 @@ class FakePaintedScrollbarLayer : public PaintedScrollbarLayer {
 
   virtual void PushPropertiesTo(LayerImpl* layer) override;
 
-  scoped_ptr<base::AutoReset<bool> > IgnoreSetNeedsCommit();
+  scoped_ptr<base::AutoReset<bool>> IgnoreSetNeedsCommit();
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
diff --git a/cc/test/layer_tree_host_common_test.h b/cc/test/layer_tree_host_common_test.h
index f5dc48e..38b57d4 100644
--- a/cc/test/layer_tree_host_common_test.h
+++ b/cc/test/layer_tree_host_common_test.h
@@ -122,7 +122,7 @@ class LayerTreeHostCommonTestBase {
 
  private:
   scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
-  scoped_ptr<std::vector<LayerImpl*> > render_surface_layer_list_impl_;
+  scoped_ptr<std::vector<LayerImpl*>> render_surface_layer_list_impl_;
 
   FakeLayerTreeHostClient client_;
   int render_surface_layer_list_count_;
diff --git a/cc/test/layer_tree_pixel_test.h b/cc/test/layer_tree_pixel_test.h
index a29e0f12..eae283b 100644
--- a/cc/test/layer_tree_pixel_test.h
+++ b/cc/test/layer_tree_pixel_test.h
@@ -100,7 +100,7 @@ class LayerTreePixelTest : public LayerTreeTest {
   Layer* readback_target_;
   base::FilePath ref_file_;
   scoped_ptr<SkBitmap> result_bitmap_;
-  std::vector<scoped_refptr<TextureLayer> > texture_layers_;
+  std::vector<scoped_refptr<TextureLayer>> texture_layers_;
   int pending_texture_mailbox_callbacks_;
   bool impl_side_painting_;
 };
diff --git a/cc/test/ordered_simple_task_runner.cc b/cc/test/ordered_simple_task_runner.cc
index 48afd9b..9cad797 100644
--- a/cc/test/ordered_simple_task_runner.cc
+++ b/cc/test/ordered_simple_task_runner.cc
@@ -157,13 +157,13 @@ const size_t OrderedSimpleTaskRunner::kAbsoluteMaxTasks =
 
 bool OrderedSimpleTaskRunner::RunTasksWhile(
     base::Callback<bool(void)> condition) {
-  std::vector<base::Callback<bool(void)> > conditions(1);
+  std::vector<base::Callback<bool(void)>> conditions(1);
   conditions[0] = condition;
   return RunTasksWhile(conditions);
 }
 
 bool OrderedSimpleTaskRunner::RunTasksWhile(
-    const std::vector<base::Callback<bool(void)> >& conditions) {
+    const std::vector<base::Callback<bool(void)>>& conditions) {
   TRACE_EVENT2("cc",
                "OrderedSimpleTaskRunner::RunPendingTasks",
                "this",
@@ -179,7 +179,7 @@ bool OrderedSimpleTaskRunner::RunTasksWhile(
                                                       true);
 
   // Make a copy so we can append some extra run checks.
-  std::vector<base::Callback<bool(void)> > modifiable_conditions(conditions);
+  std::vector<base::Callback<bool(void)>> modifiable_conditions(conditions);
 
   // Provide a timeout base on number of tasks run so this doesn't loop
   // forever.
@@ -195,7 +195,7 @@ bool OrderedSimpleTaskRunner::RunTasksWhile(
   while (pending_tasks_.size() > 0) {
     // Check if we should continue to run pending tasks.
     bool condition_success = true;
-    for (std::vector<base::Callback<bool(void)> >::iterator it =
+    for (std::vector<base::Callback<bool(void)>>::iterator it =
              modifiable_conditions.begin();
          it != modifiable_conditions.end();
          it++) {
@@ -231,7 +231,7 @@ bool OrderedSimpleTaskRunner::RunPendingTasks() {
 }
 
 bool OrderedSimpleTaskRunner::RunUntilIdle() {
-  return RunTasksWhile(std::vector<base::Callback<bool(void)> >());
+  return RunTasksWhile(std::vector<base::Callback<bool(void)>>());
 }
 
 bool OrderedSimpleTaskRunner::RunUntilTime(base::TimeTicks time) {
diff --git a/cc/test/ordered_simple_task_runner.h b/cc/test/ordered_simple_task_runner.h
index 68c9587..ee80efe7 100644
--- a/cc/test/ordered_simple_task_runner.h
+++ b/cc/test/ordered_simple_task_runner.h
@@ -87,8 +87,7 @@ class OrderedSimpleTaskRunner : public base::SingleThreadTaskRunner {
   // calling all remaining conditions. Conditions can have side effects,
   // including modifying the task queue.
   // Returns true if there are still pending tasks left.
-  bool RunTasksWhile(
-      const std::vector<base::Callback<bool(void)> >& conditions);
+  bool RunTasksWhile(const std::vector<base::Callback<bool(void)>>& conditions);
 
   // Convenience functions to run tasks with common conditions.
 
diff --git a/cc/test/ordered_texture_map.h b/cc/test/ordered_texture_map.h
index 4797c59..2aa3111 100644
--- a/cc/test/ordered_texture_map.h
+++ b/cc/test/ordered_texture_map.h
@@ -32,8 +32,7 @@ class OrderedTextureMap {
   GLuint IdAt(size_t index);
 
  private:
-  typedef base::hash_map<GLuint, scoped_refptr<TestTexture> >
-      TextureMap;
+  typedef base::hash_map<GLuint, scoped_refptr<TestTexture>> TextureMap;
   typedef std::vector<GLuint> TextureList;
 
   TextureMap textures_;
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index c7381b3..4e80fc6 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -242,7 +242,7 @@ template <typename LayerType>
 void UpdateAccumulatedSurfaceState(
     LayerType* layer,
     const gfx::Rect& drawable_content_rect,
-    std::vector<AccumulatedSurfaceState<LayerType> >*
+    std::vector<AccumulatedSurfaceState<LayerType>>*
         accumulated_surface_state) {
   if (IsRootLayer(layer))
     return;
@@ -284,7 +284,7 @@ void UpdateAccumulatedSurfaceState(
   // We must have at least one entry in the vector for the root.
   DCHECK_LT(0ul, accumulated_surface_state->size());
 
-  typedef typename std::vector<AccumulatedSurfaceState<LayerType> >
+  typedef typename std::vector<AccumulatedSurfaceState<LayerType>>
       AccumulatedSurfaceStateVector;
   typedef typename AccumulatedSurfaceStateVector::reverse_iterator
       AccumulatedSurfaceStateIterator;
@@ -1451,7 +1451,7 @@ static void CalculateDrawPropertiesInternal(
     const DataForRecursion<LayerType>& data_from_ancestor,
     typename LayerType::RenderSurfaceListType* render_surface_layer_list,
     typename LayerType::LayerListType* layer_list,
-    std::vector<AccumulatedSurfaceState<LayerType> >* accumulated_surface_state,
+    std::vector<AccumulatedSurfaceState<LayerType>>* accumulated_surface_state,
     int current_render_surface_layer_list_id) {
   // This function computes the new matrix transformations recursively for this
   // layer and all its descendants. It also computes the appropriate render
@@ -2398,7 +2398,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
-  std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state;
+  std::vector<AccumulatedSurfaceState<Layer>> accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer>(
       inputs->root_layer,
       globals,
@@ -2427,8 +2427,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
-  std::vector<AccumulatedSurfaceState<LayerImpl> >
-      accumulated_surface_state;
+  std::vector<AccumulatedSurfaceState<LayerImpl>> accumulated_surface_state;
   CalculateDrawPropertiesInternal<LayerImpl>(
       inputs->root_layer,
       globals,
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 17dd4a8..83e6800 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "cc/trees/layer_tree_host_common.h"
 
+#include <algorithm>
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
@@ -7505,7 +7506,7 @@ TEST_F(LayerTreeHostCommonTest, DoNotClobberSorting) {
   scroll_parent_clip->SetMasksToBounds(true);
 
   scroll_child->SetScrollParent(scroll_parent.get());
-  scoped_ptr<std::set<LayerImpl*> > scroll_children(new std::set<LayerImpl*>);
+  scoped_ptr<std::set<LayerImpl*>> scroll_children(new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child.get());
   scroll_parent->SetScrollChildren(scroll_children.release());
 
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 2881f62..c5dbe0d 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -3387,7 +3387,7 @@ class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
         // avoid causing a second commit to be scheduled. If a property change
         // is made during this, however, it needs to be pushed in the upcoming
         // commit.
-        scoped_ptr<base::AutoReset<bool> > ignore =
+        scoped_ptr<base::AutoReset<bool>> ignore =
             scrollbar_layer_->IgnoreSetNeedsCommit();
 
         scrollbar_layer_->SetBounds(gfx::Size(30, 30));
diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc
index 943299d..3e22f04 100644
--- a/cc/trees/layer_tree_host_unittest_occlusion.cc
+++ b/cc/trees/layer_tree_host_unittest_occlusion.cc
@@ -584,7 +584,7 @@ class LayerTreeHostOcclusionTestManySurfaces
   virtual void SetupTree() override {
     // We create enough RenderSurfaces that it will trigger Vector reallocation
     // while computing occlusion.
-    std::vector<scoped_refptr<TestLayer> > layers;
+    std::vector<scoped_refptr<TestLayer>> layers;
     int num_surfaces = 200;
     int root_width = 400;
     int root_height = 400;
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 3316855..5fc01fc 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -510,7 +510,7 @@ bool LayerTreeImpl::UpdateDrawProperties() {
                  IsActiveTree(),
                  "SourceFrameNumber",
                  source_frame_number_);
-    scoped_ptr<OcclusionTracker<LayerImpl> > occlusion_tracker;
+    scoped_ptr<OcclusionTracker<LayerImpl>> occlusion_tracker;
     if (settings().use_occlusion_for_tile_prioritization) {
       occlusion_tracker.reset(new OcclusionTracker<LayerImpl>(
           root_layer()->render_surface()->content_rect()));