Split up software and gpu raster time UMA stats

cc/tiles/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/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/optional.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/histograms.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/task_category.h"
 #include "cc/tiles/tile.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
+// TODO(enne): remove this histogram and its monitoring in M58 once there is
+// enough new data from the other two raster task timers.
 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
-    ScopedRasterTaskTimer,
+    ScopedGeneralRasterTaskTimer,
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
+DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
+    ScopedSoftwareRasterTaskTimer,
+    "Compositing.%s.RasterTask.RasterUs.Software",
+    "Compositing.%s.RasterTask.RasterPixelsPerMs.Software");
+
+DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
+    ScopedGpuRasterTaskTimer,
+    "Compositing.%s.RasterTask.RasterUs.Gpu",
+    "Compositing.%s.RasterTask.RasterPixelsPerMs.Gpu");
+
+class ScopedRasterTaskTimer {
+ public:
+  explicit ScopedRasterTaskTimer(bool use_gpu_rasterization) {
+    if (use_gpu_rasterization)
+      gpu_timer_.emplace();
+    else
+      software_timer_.emplace();
+  }
+
+  void SetArea(int area) {
+    general_timer_.SetArea(area);
+    if (software_timer_)
+      software_timer_->SetArea(area);
+    if (gpu_timer_)
+      gpu_timer_->SetArea(area);
+  }
+
+ private:
+  ScopedGeneralRasterTaskTimer general_timer_;
+  base::Optional<ScopedSoftwareRasterTaskTimer> software_timer_;
+  base::Optional<ScopedGpuRasterTaskTimer> gpu_timer_;
+};
+
 class RasterTaskImpl : public TileTask {
  public:
   RasterTaskImpl(TileManager* tile_manager,
                  Tile* tile,
                  Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
                  const RasterSource::PlaybackSettings& playback_settings,
                  TileResolution tile_resolution,
                  gfx::Rect invalidated_rect,
                  uint64_t source_prepare_tiles_id,
                  std::unique_ptr<RasterBuffer> raster_buffer,
                  TileTask::Vector* dependencies,
-                 bool supports_concurrent_execution)
-      : TileTask(supports_concurrent_execution, dependencies),
+                 bool is_gpu_rasterization)
+      : TileTask(!is_gpu_rasterization, dependencies),
         tile_manager_(tile_manager),
         tile_(tile),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(tile->content_rect()),
         invalid_content_rect_(invalidated_rect),
         contents_scale_(tile->contents_scale()),
         playback_settings_(playback_settings),
         tile_resolution_(tile_resolution),
         layer_id_(tile->layer_id()),
         source_prepare_tiles_id_(source_prepare_tiles_id),
         tile_tracing_id_(static_cast<void*>(tile)),
         new_content_id_(tile->id()),
         source_frame_number_(tile->source_frame_number()),
+        is_gpu_rasterization_(is_gpu_rasterization),
         raster_buffer_(std::move(raster_buffer)) {
     DCHECK(origin_thread_checker_.CalledOnValidThread());
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_tracing_id_, tile_resolution_, source_frame_number_, layer_id_);
-    ScopedRasterTaskTimer timer;
+    ScopedRasterTaskTimer timer(is_gpu_rasterization_);
     timer.SetArea(content_rect_.size().GetArea());
 
     DCHECK(raster_source_);
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              invalid_content_rect_, new_content_id_,
                              contents_scale_, playback_settings_);
   }
 
   // Overridden from TileTask:
@@ skipping 28 matching lines @@
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
   float contents_scale_;
   RasterSource::PlaybackSettings playback_settings_;
   TileResolution tile_resolution_;
   int layer_id_;
   uint64_t source_prepare_tiles_id_;
   void* tile_tracing_id_;
   uint64_t new_content_id_;
   int source_frame_number_;
+  bool is_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 TaskCategory TaskCategoryForTileTask(TileTask* task,
                                      bool use_foreground_category) {
   if (!task->supports_concurrent_execution())
     return TASK_CATEGORY_NONCONCURRENT_FOREGROUND;
 
@@ skipping 820 matching lines @@
   }
 
   // We can skip the image hijack canvas if we have no images.
   playback_settings.use_image_hijack_canvas = !images.empty();
 
   // Get the tasks for the required images.
   ImageDecodeController::TracingInfo tracing_info(
       prepare_tiles_count_, prioritized_tile.priority().priority_bin);
   image_manager_.GetTasksForImagesAndRef(&images, &decode_tasks, tracing_info);
 
-  bool supports_concurrent_execution = !use_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer =
       raster_buffer_provider_->AcquireBufferForRaster(
           resource, resource_content_id, tile->invalidated_id());
   return make_scoped_refptr(new RasterTaskImpl(
       this, tile, resource, prioritized_tile.raster_source(), playback_settings,
       prioritized_tile.priority().resolution, invalidated_rect,
       prepare_tiles_count_, std::move(raster_buffer), &decode_tasks,
-      supports_concurrent_execution));
+      use_gpu_rasterization_));
 }
 
 void TileManager::OnRasterTaskCompleted(
     std::unique_ptr<RasterBuffer> raster_buffer,
     Tile* tile,
     Resource* resource,
     bool was_canceled) {
   DCHECK(tile);
   DCHECK(tiles_.find(tile->id()) != tiles_.end());
   raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer));
@@ skipping 334 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc