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;
-
-  // 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;
-
-    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);
+class BitmapSerializer : public SkPixelSerializer {
+ protected:
+  bool onUseEncodedData(const void* data, size_t len) override {
+    // For now, always force our onEncodePixels by returning false.
+    // If we have way to sniff the data to see that it is already PNG or JPEG
+    // we could return true to skip re-encoding it.
+    return false;

[scroggo, 2014/12/19 20:02:18]

This is a change in behavior. The old SkWriteBuffer::writeBitmap used the
existing decoded data if it was there.

I'm not aware of what the caller wants, but just wanted to point out that this
is different.

(The old EncodeBitmap function in gpu_benchmarking_extension.cc unnecessarily
checked refEncodedData, because an even earlier version of writeBitmap did not
call it first.)

[enne (OOO), 2014/12/19 21:15:13]

If this can be done better, that'd be nice, but this is only used for putting
pictures into traces for FrameViewer.

[reed1, 2014/12/19 21:30:01]

Done.

[reed1, 2014/12/19 21:30:02]

Acknowledged.

   }
 
-  if (encoding_succeeded) {
-    *offset = 0;
-    return SkData::NewWithCopy(&data.front(), data.size());
+  SkData* onEncodePixels(const SkImageInfo& info,
+                         void* pixels,

[scroggo, 2014/12/19 20:02:18]

Once https://codereview.chromium.org/788143007/ lands, this is const void*.
(Same for gpu_benchmarking_extension.cc.)

[reed1, 2014/12/19 21:30:02]

Acknowledged.

+                         size_t rowBytes) override {

[enne (OOO), 2014/12/19 21:15:13]

row_bytes

[reed1, 2014/12/19 21:30:01]

Done.

+    const int kJpegQuality = 80;
+    std::vector<unsigned char> 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<unsigned char*>(pixels),
+                                 gfx::JPEGCodec::FORMAT_SkBitmap, info.width(),
+                                 info.height(), rowBytes, kJpegQuality, &data);
+    } else {
+      SkBitmap bm;
+      // The cast is ok, since we only read the bm.
+      if (!bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {
+        return NULL;

[enne (OOO), 2014/12/19 21:15:13]

nullptr

[reed1, 2014/12/19 21:30:02]

Done.

+      }
+      encoding_succeeded = gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &data);
+    }
+
+    if (encoding_succeeded) {
+      return SkData::NewWithCopy(&data.front(), data.size());
+    }
+    return NULL;
   }
-  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