cc: Remove the Inputs struct from DisplayItemList

cc/playback/display_item_list.cc

 // Copyright 2014 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/playback/display_item_list.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 139 matching lines @@
       break;
     }
     case DisplayItem::END_TRANSFORM:
       canvas->restore();
       break;
   }
 }
 
 }  // namespace
 
-DisplayItemList::Inputs::Inputs()
-    : items(LargestDisplayItemSize(),
-            LargestDisplayItemSize() * kDefaultNumDisplayItemsToReserve) {}
-
-DisplayItemList::Inputs::~Inputs() = default;
-
-DisplayItemList::DisplayItemList() = default;
+DisplayItemList::DisplayItemList()
+    : items_(LargestDisplayItemSize(),
+             LargestDisplayItemSize() * kDefaultNumDisplayItemsToReserve) {}
 
 DisplayItemList::~DisplayItemList() = default;
 
 void DisplayItemList::Raster(SkCanvas* canvas,
                              SkPicture::AbortCallback* callback,
                              const gfx::Rect& canvas_target_playback_rect,
                              float contents_scale) const {
   canvas->save();
   if (!canvas_target_playback_rect.IsEmpty()) {
     // canvas_target_playback_rect is specified in device space. We can't
@@ skipping 10 matching lines @@
 
 void DisplayItemList::Raster(SkCanvas* canvas,
                              SkPicture::AbortCallback* callback) const {
   gfx::Rect canvas_playback_rect;
   if (!GetCanvasClipBounds(canvas, &canvas_playback_rect))
     return;
 
   std::vector<size_t> indices;
   rtree_.Search(canvas_playback_rect, &indices);
   for (size_t index : indices) {
-    RasterItem(inputs_.items[index], canvas, callback);
+    RasterItem(items_[index], canvas, callback);
 
     // We use a callback during solid color analysis on the compositor thread to
     // break out early. Since we're handling a sequence of pictures via rtree
     // query results ourselves, we have to respect the callback and early out.
     if (callback && callback->abort())
       break;
   }
 }
 
 void DisplayItemList::GrowCurrentBeginItemVisualRect(
     const gfx::Rect& visual_rect) {
-  if (!inputs_.begin_item_indices.empty())
-    inputs_.visual_rects[inputs_.begin_item_indices.back()].Union(visual_rect);
+  if (!begin_item_indices_.empty())
+    visual_rects_[begin_item_indices_.back()].Union(visual_rect);
 }
 
 void DisplayItemList::Finalize() {
   TRACE_EVENT0("cc", "DisplayItemList::Finalize");
-  DCHECK(inputs_.items.size() == inputs_.visual_rects.size())
-      << "items.size() " << inputs_.items.size() << " visual_rects.size() "
-      << inputs_.visual_rects.size();
-  rtree_.Build(inputs_.visual_rects);
+  DCHECK(items_.size() == visual_rects_.size())
+      << "items.size() " << items_.size() << " visual_rects.size() "
+      << visual_rects_.size();
+  rtree_.Build(visual_rects_);
 
   if (!retain_visual_rects_)
     // This clears both the vector and the vector's capacity, since
     // visual_rects won't be used anymore.
-    std::vector<gfx::Rect>().swap(inputs_.visual_rects);
+    std::vector<gfx::Rect>().swap(visual_rects_);
 }
 
 bool DisplayItemList::IsSuitableForGpuRasterization() const {
   // TODO(wkorman): This is more permissive than Picture's implementation, since
   // none of the items might individually trigger a veto even though they
   // collectively have enough "bad" operations that a corresponding Picture
   // would get vetoed. See crbug.com/513016.
-  return inputs_.all_items_are_suitable_for_gpu_rasterization;
+  return all_items_are_suitable_for_gpu_rasterization_;
 }
 
 int DisplayItemList::ApproximateOpCount() const {
   return approximate_op_count_;
 }
 
 size_t DisplayItemList::ApproximateMemoryUsage() const {
   size_t memory_usage = sizeof(*this);
 
   size_t external_memory_usage = 0;
-  for (const auto& item : inputs_.items) {
+  for (const auto& item : items_) {
     size_t bytes = 0;
     switch (item.type) {
       case DisplayItem::CLIP:
         bytes = static_cast<const ClipDisplayItem&>(item).ExternalMemoryUsage();
         break;
       case DisplayItem::CLIP_PATH:
         bytes =
             static_cast<const ClipPathDisplayItem&>(item).ExternalMemoryUsage();
         break;
       case DisplayItem::COMPOSITING:
@@ skipping 21 matching lines @@
       case DisplayItem::END_COMPOSITING:
       case DisplayItem::END_FLOAT_CLIP:
       case DisplayItem::END_FILTER:
       case DisplayItem::END_TRANSFORM:
         break;
     }
     external_memory_usage += bytes;
   }
 
   // Memory outside this class due to |items_|.
-  memory_usage += inputs_.items.GetCapacityInBytes() + external_memory_usage;
+  memory_usage += items_.GetCapacityInBytes() + external_memory_usage;
 
   // TODO(jbroman): Does anything else owned by this class substantially
   // contribute to memory usage?
   // TODO(vmpstr): Probably DiscardableImageMap is worth counting here.
 
   return memory_usage;
 }
 
 bool DisplayItemList::ShouldBeAnalyzedForSolidColor() const {
   return ApproximateOpCount() <= kOpCountThatIsOkToAnalyze;
@@ skipping 11 matching lines @@
 }
 
 std::unique_ptr<base::trace_event::TracedValue>
 DisplayItemList::CreateTracedValue(bool include_items) const {
   auto state = base::MakeUnique<base::trace_event::TracedValue>();
   state->BeginDictionary("params");
 
   if (include_items) {
     state->BeginArray("items");
 
-    auto visual_rects_it = inputs_.visual_rects.begin();
-    for (const DisplayItem& base_item : inputs_.items) {
+    auto visual_rects_it = visual_rects_.begin();
+    for (const DisplayItem& base_item : items_) {
       gfx::Rect visual_rect;
-      if (visual_rects_it != inputs_.visual_rects.end()) {
+      if (visual_rects_it != visual_rects_.end()) {
         visual_rect = *visual_rects_it;
         ++visual_rects_it;
       }
 
       switch (base_item.type) {
         case DisplayItem::CLIP: {
           const auto& item = static_cast<const ClipDisplayItem&>(base_item);
           std::string output =
               base::StringPrintf("ClipDisplayItem rect: [%s] visualRect: [%s]",
                                  item.clip_rect.ToString().c_str(),
@@ skipping 153 matching lines @@
 }
 
 void DisplayItemList::GenerateDiscardableImagesMetadata() {
   // This should be only called once.
   DCHECK(image_map_.empty());
 
   gfx::Rect bounds = rtree_.GetBounds();
   DiscardableImageMap::ScopedMetadataGenerator generator(
       &image_map_, gfx::Size(bounds.right(), bounds.bottom()));
   auto* canvas = generator.canvas();
-  for (const auto& item : inputs_.items)
+  for (const auto& item : items_)
     RasterItem(item, canvas, nullptr);
 }
 
 void DisplayItemList::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     float contents_scale,
     std::vector<DrawImage>* images) {
   image_map_.GetDiscardableImagesInRect(rect, contents_scale, images);
 }
 
 gfx::Rect DisplayItemList::GetRectForImage(ImageId image_id) const {
   return image_map_.GetRectForImage(image_id);
 }
 
 }  // namespace cc