Move cc::DisplayItemList and related classes into cc/paint/

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 183 matching lines @@
     AppendDebugBorderQuad(
         render_pass, bounds(), shared_quad_state, append_quads_data);
 
     SolidColorLayerImpl::AppendSolidQuads(
         render_pass, draw_properties().occlusion_in_content_space,
         shared_quad_state, visible_layer_rect(),
         raster_source_->GetSolidColor(), append_quads_data);
     return;
   }
 
+  float device_scale_factor =
+      layer_tree_impl() ? layer_tree_impl()->device_scale_factor() : 1;
   float max_contents_scale = MaximumTilingContentsScale();
   PopulateScaledSharedQuadState(shared_quad_state, max_contents_scale,
                                 max_contents_scale);
   Occlusion scaled_occlusion =
       draw_properties()
           .occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
               shared_quad_state->quad_to_target_transform);
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
         render_pass, shared_quad_state->quad_layer_bounds, shared_quad_state,
         append_quads_data, DebugColors::DirectPictureBorderColor(),
-        DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
+        DebugColors::DirectPictureBorderWidth(device_scale_factor));
 
     gfx::Rect geometry_rect = shared_quad_state->visible_quad_layer_rect;
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
 
     // The raster source may not be valid over the entire visible rect,
     // and rastering outside of that may cause incorrect pixels.
     gfx::Rect scaled_recorded_viewport = gfx::ScaleToEnclosingRect(
         raster_source_->RecordedViewport(), max_contents_scale);
@@ skipping 26 matching lines @@
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(), max_contents_scale,
              shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
          iter; ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->draw_info().IsReadyToDraw()) {
         TileDrawInfo::Mode mode = iter->draw_info().mode();
         if (mode == TileDrawInfo::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
-          width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
+          width = DebugColors::SolidColorTileBorderWidth(device_scale_factor);
         } else if (mode == TileDrawInfo::OOM_MODE) {
           color = DebugColors::OOMTileBorderColor();
-          width = DebugColors::OOMTileBorderWidth(layer_tree_impl());
+          width = DebugColors::OOMTileBorderWidth(device_scale_factor);
         } else if (iter->draw_info().has_compressed_resource()) {
           color = DebugColors::CompressedTileBorderColor();
-          width = DebugColors::CompressedTileBorderWidth(layer_tree_impl());
+          width = DebugColors::CompressedTileBorderWidth(device_scale_factor);
         } else if (iter.resolution() == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
-          width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
+          width = DebugColors::HighResTileBorderWidth(device_scale_factor);
         } else if (iter.resolution() == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
-          width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
+          width = DebugColors::LowResTileBorderWidth(device_scale_factor);
         } else if (iter->contents_scale() > max_contents_scale) {
           color = DebugColors::ExtraHighResTileBorderColor();
-          width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
+          width = DebugColors::ExtraHighResTileBorderWidth(device_scale_factor);
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
-          width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl());
+          width = DebugColors::ExtraLowResTileBorderWidth(device_scale_factor);
         }
       } else {
         color = DebugColors::MissingTileBorderColor();
-        width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
+        width = DebugColors::MissingTileBorderWidth(device_scale_factor);
       }
 
       DebugBorderDrawQuad* debug_border_quad =
           render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
       gfx::Rect geometry_rect = iter.geometry_rect();
       gfx::Rect visible_geometry_rect = geometry_rect;
       debug_border_quad->SetNew(shared_quad_state,
                                 geometry_rect,
                                 visible_geometry_rect,
                                 color,
@@ skipping 965 matching lines @@
                std::max(GetIdealContentsScale(), min_contents_scale));
   ideal_source_scale_ =
       ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.IdealContentsScale",
                               ideal_contents_scale_, 1, 10000, 50);
 }
 
 void PictureLayerImpl::GetDebugBorderProperties(
     SkColor* color,
     float* width) const {
+  float device_scale_factor =
+      layer_tree_impl() ? layer_tree_impl()->device_scale_factor() : 1;
+
   if (is_directly_composited_image_) {
     *color = DebugColors::ImageLayerBorderColor();
-    *width = DebugColors::ImageLayerBorderWidth(layer_tree_impl());
+    *width = DebugColors::ImageLayerBorderWidth(device_scale_factor);
   } else {
     *color = DebugColors::TiledContentLayerBorderColor();
-    *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
+    *width = DebugColors::TiledContentLayerBorderWidth(device_scale_factor);
   }
 }
 
 void PictureLayerImpl::GetAllPrioritizedTilesForTracing(
     std::vector<PrioritizedTile>* prioritized_tiles) const {
   if (!tilings_)
     return;
   tilings_->GetAllPrioritizedTilesForTracing(prioritized_tiles);
 }
 
@@ skipping 100 matching lines @@
   }
 
   invalidation_.Union(invalidation);
   tilings_->UpdateTilingsForImplSideInvalidation(invalidation);
   SetNeedsPushProperties();
   TRACE_EVENT_END1("cc", "PictureLayerImpl::InvalidateRegionForImages",
                    "Invalidation", invalidation.ToString());
 }
 
 }  // namespace cc