cc: Gather and lock/unlock SkDiscardablePixelRefs instead of skia::LazyPixelRefs.

cc/resources/picture.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/picture.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/traced_picture.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/content_layer_client.h"
-#include "skia/ext/lazy_pixel_ref_utils.h"
+#include "skia/ext/pixel_ref_utils.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDrawFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 226 matching lines @@
       tile_grid_info.fTileInterval.height() +
           2 * tile_grid_info.fMargin.height());
   DCHECK_GT(cell_size_.width(), 0);
   DCHECK_GT(cell_size_.height(), 0);
 
   int min_x = std::numeric_limits<int>::max();
   int min_y = std::numeric_limits<int>::max();
   int max_x = 0;
   int max_y = 0;
 
-  skia::LazyPixelRefList pixel_refs;
-  skia::LazyPixelRefUtils::GatherPixelRefs(picture_.get(), &pixel_refs);
-  for (skia::LazyPixelRefList::const_iterator it = pixel_refs.begin();
+  skia::DiscardablePixelRefList pixel_refs;
+  skia::PixelRefUtils::GatherDiscardablePixelRefs(picture_.get(), &pixel_refs);
+  for (skia::DiscardablePixelRefList::const_iterator it = pixel_refs.begin();
        it != pixel_refs.end();
        ++it) {
     gfx::Point min(
         RoundDown(static_cast<int>(it->pixel_ref_rect.x()),
                   cell_size_.width()),
         RoundDown(static_cast<int>(it->pixel_ref_rect.y()),
                   cell_size_.height()));
     gfx::Point max(
         RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
                   cell_size_.width()),
         RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
                   cell_size_.height()));
 
     for (int y = min.y(); y <= max.y(); y += cell_size_.height()) {
       for (int x = min.x(); x <= max.x(); x += cell_size_.width()) {
         PixelRefMapKey key(x, y);
-        pixel_refs_[key].push_back(it->lazy_pixel_ref);
+        pixel_refs_[key].push_back(it->pixel_ref);
       }
     }
 
     min_x = std::min(min_x, min.x());
     min_y = std::min(min_y, min.y());
     max_x = std::max(max_x, max.x());
     max_y = std::max(max_y, max.y());
   }
 
   min_pixel_cell_ = gfx::Point(min_x, min_y);
@@ skipping 185 matching lines @@
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   record_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   record_data->SetInteger("width", layer_rect_.width());
   record_data->SetInteger("height", layer_rect_.height());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc