Update from https://crrev.com/312398

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/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/picture_debug_util.h"
 #include "cc/debug/traced_picture.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/content_layer_client.h"
 #include "skia/ext/pixel_ref_utils.h"
-#include "third_party/skia/include/core/SkBBHFactory.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDrawPictureCallback.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/utils/SkNullCanvas.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/geometry/rect_conversions.h"
@@ skipping 14 matching lines @@
   scoped_ptr<SkBitmap> decoded_jpeg(gfx::JPEGCodec::Decode(data, size));
   if (decoded_jpeg) {
     *bm = *decoded_jpeg;
     return true;
   }
   return false;
 }
 
 }  // namespace
 
-scoped_refptr<Picture> Picture::Create(
-    const gfx::Rect& layer_rect,
-    ContentLayerClient* client,
-    const SkTileGridFactory::TileGridInfo& tile_grid_info,
-    bool gather_pixel_refs,
-    RecordingMode recording_mode) {
+scoped_refptr<Picture> Picture::Create(const gfx::Rect& layer_rect,
+                                       ContentLayerClient* client,
+                                       const gfx::Size& tile_grid_size,
+                                       bool gather_pixel_refs,
+                                       RecordingMode recording_mode) {
   scoped_refptr<Picture> picture = make_scoped_refptr(new Picture(layer_rect));
 
-  picture->Record(client, tile_grid_info, recording_mode);
+  picture->Record(client, tile_grid_size, recording_mode);
   if (gather_pixel_refs)
-    picture->GatherPixelRefs(tile_grid_info);
+    picture->GatherPixelRefs(tile_grid_size);
 
   return picture;
 }
 
 Picture::Picture(const gfx::Rect& layer_rect)
   : layer_rect_(layer_rect),
     cell_size_(layer_rect.size()) {
   // Instead of recording a trace event for object creation here, we wait for
   // the picture to be recorded in Picture::Record.
 }
@@ skipping 85 matching lines @@
   DCHECK(picture_);
   return SkPictureUtils::ApproximateBytesUsed(picture_.get());
 }
 
 bool Picture::HasText() const {
   DCHECK(picture_);
   return picture_->hasText();
 }
 
 void Picture::Record(ContentLayerClient* painter,
-                     const SkTileGridFactory::TileGridInfo& tile_grid_info,
+                     const gfx::Size& tile_grid_size,
                      RecordingMode recording_mode) {
   TRACE_EVENT2("cc",
                "Picture::Record",
                "data",
                AsTraceableRecordData(),
                "recording_mode",
                recording_mode);
 
   DCHECK(!picture_);
-  DCHECK(!tile_grid_info.fTileInterval.isEmpty());
+  DCHECK(!tile_grid_size.IsEmpty());
 
   // TODO(mtklein): If SkRTree sticks, clean up tile_grid_info.  skbug.com/3085
   SkRTreeFactory factory;
   SkPictureRecorder recorder;
 
   skia::RefPtr<SkCanvas> canvas;
   canvas = skia::SharePtr(recorder.beginRecording(
       layer_rect_.width(), layer_rect_.height(), &factory,
       SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag));
 
@@ skipping 31 matching lines @@
 
   painter->PaintContents(canvas.get(), layer_rect_, graphics_context_status);
 
   canvas->restore();
   picture_ = skia::AdoptRef(recorder.endRecording());
   DCHECK(picture_);
 
   EmitTraceSnapshot();
 }
 
-void Picture::GatherPixelRefs(
-    const SkTileGridFactory::TileGridInfo& tile_grid_info) {
+void Picture::GatherPixelRefs(const gfx::Size& tile_grid_size) {
   TRACE_EVENT2("cc", "Picture::GatherPixelRefs",
                "width", layer_rect_.width(),
                "height", layer_rect_.height());
 
   DCHECK(picture_);
   DCHECK(pixel_refs_.empty());
   if (!WillPlayBackBitmaps())
     return;
-  cell_size_ = gfx::Size(
-      tile_grid_info.fTileInterval.width() +
-          2 * tile_grid_info.fMargin.width(),
-      tile_grid_info.fTileInterval.height() +
-          2 * tile_grid_info.fMargin.height());
+  cell_size_ = tile_grid_size;
   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::DiscardablePixelRefList pixel_refs;
   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture_.get(), &pixel_refs);
@@ skipping 210 matching lines @@
   TracedValue::SetIDRef(this, raster_data.get(), "picture_id");
   raster_data->SetDouble("scale", scale);
   return raster_data;
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   scoped_refptr<base::debug::TracedValue> record_data =
       new base::debug::TracedValue();
   TracedValue::SetIDRef(this, record_data.get(), "picture_id");
-  record_data->BeginArray("layer_rect");
-  MathUtil::AddToTracedValue(layer_rect_, record_data.get());
-  record_data->EndArray();
+  MathUtil::AddToTracedValue("layer_rect", layer_rect_, record_data.get());
   return record_data;
 }
 
 }  // namespace cc