Update from https://crrev.com/308331

cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 23 matching lines @@
   RasterTaskImpl(
       const Resource* resource,
       RasterSource* raster_source,
       const gfx::Rect& content_rect,
       float contents_scale,
       TileResolution tile_resolution,
       int layer_id,
       const void* tile_id,
       int source_frame_number,
       bool analyze_picture,
-      RenderingStatsInstrumentation* rendering_stats,
       const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
           reply,
       ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
         raster_source_(raster_source),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         analyze_picture_(analyze_picture),
-        rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     if (analyze_picture_) {
@@ skipping 53 matching lines @@
 
   RasterSource::SolidColorAnalysis analysis_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   float contents_scale_;
   TileResolution tile_resolution_;
   int layer_id_;
   const void* tile_id_;
   int source_frame_number_;
   bool analyze_picture_;
-  RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
       reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
                       int layer_id,
-                      RenderingStatsInstrumentation* rendering_stats,
                       const base::Callback<void(bool was_canceled)>& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
         layer_id_(layer_id),
-        rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
 
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         pixel_ref_.get());
     // This will cause the image referred to by pixel ref to be decoded.
     pixel_ref_->lockPixels();
     pixel_ref_->unlockPixels();
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {}
   void CompleteOnOriginThread(TileTaskClient* client) override {}
   void RunReplyOnOriginThread() override { reply_.Run(!HasFinishedRunning()); }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
-  RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(bool was_canceled)> reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 const char* TaskSetName(TaskSet task_set) {
   switch (task_set) {
     case TileManager::ALL:
       return "ALL";
     case TileManager::REQUIRED_FOR_ACTIVATION:
@@ skipping 19 matching lines @@
   state->SetInteger("canceled_count", stats.canceled_count);
   return state;
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation,
     size_t scheduled_raster_task_limit) {
-  return make_scoped_ptr(new TileManager(
-      client, task_runner, resource_pool, tile_task_runner,
-      rendering_stats_instrumentation, scheduled_raster_task_limit));
+  return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
+                                         tile_task_runner,
+                                         scheduled_raster_task_limit));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    RenderingStatsInstrumentation* rendering_stats_instrumentation,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
       tile_task_runner_(tile_task_runner),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
-      rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       did_notify_ready_to_activate_(false),
@@ skipping 469 matching lines @@
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
 scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return make_scoped_refptr(new ImageDecodeTaskImpl(
       pixel_ref,
       tile->layer_id(),
-      rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
@@ skipping 26 matching lines @@
   return make_scoped_refptr(
       new RasterTaskImpl(const_resource,
                          tile->raster_source(),
                          tile->content_rect(),
                          tile->contents_scale(),
                          mts.resolution,
                          tile->layer_id(),
                          static_cast<const void*>(tile),
                          tile->source_frame_number(),
                          tile->use_picture_analysis(),
-                         rendering_stats_instrumentation_,
                          base::Bind(&TileManager::OnRasterTaskCompleted,
                                     base::Unretained(this),
                                     tile->id(),
                                     base::Passed(&resource)),
                          &decode_tasks));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
                                              SkPixelRef* pixel_ref,
                                              bool was_canceled) {
@@ skipping 171 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc