use new PixelSerializer API, remove legacy flag

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/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/SkData.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "third_party/skia/include/core/SkPixelSerializer.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"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 namespace {
 
-SkData* EncodeBitmap(size_t* offset, const SkBitmap& bm) {
-  const int kJpegQuality = 80;
-  std::vector<unsigned char> data;
+class BitmapSerializer : public SkPixelSerializer {
+ protected:
+  bool onUseEncodedData(const void* data, size_t len) override { return true; }
 
-  // If bitmap is opaque, encode as JPEG.
-  // Otherwise encode as PNG.
-  bool encoding_succeeded = false;
-  if (bm.isOpaque()) {
-    SkAutoLockPixels lock_bitmap(bm);
-    if (bm.empty())
-      return NULL;
+  SkData* onEncodePixels(const SkImageInfo& info,
+                         const void* pixels,
+                         size_t row_bytes) override {
+    const int kJpegQuality = 80;
+    std::vector<unsigned char> data;
 
-    encoding_succeeded = gfx::JPEGCodec::Encode(
-        reinterpret_cast<unsigned char*>(bm.getAddr32(0, 0)),
-        gfx::JPEGCodec::FORMAT_SkBitmap,
-        bm.width(),
-        bm.height(),
-        bm.rowBytes(),
-        kJpegQuality,
-        &data);
-  } else {
-    encoding_succeeded = gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &data);
+    // If bitmap is opaque, encode as JPEG.
+    // Otherwise encode as PNG.
+    bool encoding_succeeded = false;
+    if (info.isOpaque()) {
+      encoding_succeeded =
+          gfx::JPEGCodec::Encode(reinterpret_cast<const unsigned char*>(pixels),
+                                 gfx::JPEGCodec::FORMAT_SkBitmap, info.width(),
+                                 info.height(), row_bytes, kJpegQuality, &data);
+    } else {
+      SkBitmap bm;
+      // The cast is ok, since we only read the bm.
+      if (!bm.installPixels(info, const_cast<void*>(pixels), row_bytes)) {
+        return nullptr;
+      }
+      encoding_succeeded = gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &data);
+    }
+
+    if (encoding_succeeded) {
+      return SkData::NewWithCopy(&data.front(), data.size());
+    }
+    return nullptr;
   }
-
-  if (encoding_succeeded) {
-    *offset = 0;
-    return SkData::NewWithCopy(&data.front(), data.size());
-  }
-  return NULL;
-}
+};
 
 bool DecodeBitmap(const void* buffer, size_t size, SkBitmap* bm) {
   const unsigned char* data = static_cast<const unsigned char *>(buffer);
 
   // Try PNG first.
   if (gfx::PNGCodec::Decode(data, size, bm))
     return true;
 
   // Try JPEG.
   scoped_ptr<SkBitmap> decoded_jpeg(gfx::JPEGCodec::Decode(data, size));
@@ skipping 282 matching lines @@
   DCHECK(picture_);
   picture_->playback(canvas);
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   TRACE_EVENT_END1("cc", "Picture::Replay",
                    "num_pixels_replayed", bounds.width() * bounds.height());
 }
 
 scoped_ptr<base::Value> Picture::AsValue() const {
   SkDynamicMemoryWStream stream;
-  picture_->serialize(&stream, &EncodeBitmap);
+  BitmapSerializer serializer;
+  picture_->serialize(&stream, &serializer);
 
   // Encode the picture as base64.
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
   res->Set("params.layer_rect", MathUtil::AsValue(layer_rect_).release());
 
   size_t serialized_size = stream.bytesWritten();
   scoped_ptr<char[]> serialized_picture(new char[serialized_size]);
   stream.copyTo(serialized_picture.get());
   std::string b64_picture;
   base::Base64Encode(std::string(serialized_picture.get(), serialized_size),
@@ skipping 134 matching lines @@
   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();
   return record_data;
 }
 
 }  // namespace cc