use new PixelSerializer API, remove legacy flag

content/renderer/gpu/gpu_benchmarking_extension.cc

 // Copyright (c) 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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
@@ skipping 16 matching lines @@
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
+#include "third_party/skia/include/core/SkPixelSerializer.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "v8/include/v8.h"
 
 using blink::WebCanvas;
 using blink::WebLocalFrame;
 using blink::WebImageCache;
 using blink::WebPrivatePtr;
 using blink::WebSize;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
-// offset parameter is deprecated/ignored, and will be remove from the
-// signature in a future skia release. <reed@google.com>
-SkData* EncodeBitmapToData(size_t* offset, const SkBitmap& bm) {
-  SkPixelRef* pr = bm.pixelRef();
-  if (pr != NULL) {
-    SkData* data = pr->refEncodedData();
-    if (data != NULL)
-      return data;
+class PNGSerializer : public SkPixelSerializer {
+ protected:
+  bool onUseEncodedData(const void* data, size_t len) override {
+    // If its already encoded, we are fine with that.
+    return true;
   }
-  std::vector<unsigned char> vector;
-  if (gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &vector)) {
-    return SkData::NewWithCopy(&vector.front(), vector.size());
+
+  SkData* onEncodePixels(const SkImageInfo& info,
+                         void* pixels,
+                         size_t rowBytes) override {

[piman, 2014/12/19 20:21:42]

nit: row_bytes

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

Done.

+    SkBitmap bm;
+    // The const_cast is fine, since we only read from the bitmap.
+    if (bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {

[piman, 2014/12/19 20:21:42]

nit: no need for const_cast, pixels is already non-const.

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

A pending change in skia will require this cast (the signature will be become
const void* pixels). This will not land before that hits.

+      std::vector<unsigned char> vector;
+      if (gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &vector)) {
+        return SkData::NewWithCopy(&vector.front(), vector.size());
+      }
+    }
+    return NULL;
   }
-  return NULL;
-}
+};
 
 class SkPictureSerializer {
  public:
   explicit SkPictureSerializer(const base::FilePath& dirpath)
       : dirpath_(dirpath),
         layer_id_(0) {
     // Let skia register known effect subclasses. This basically enables
     // reflection on those subclasses required for picture serialization.
     SkiaBenchmarking::Initialize();
   }
@@ skipping 13 matching lines @@
 
     // Serialize picture to file.
     // TODO(alokp): Note that for this to work Chrome needs to be launched with
     // --no-sandbox command-line flag. Get rid of this limitation.
     // CRBUG: 139640.
     std::string filename = "layer_" + base::IntToString(layer_id_++) + ".skp";
     std::string filepath = dirpath_.AppendASCII(filename).MaybeAsASCII();
     DCHECK(!filepath.empty());
     SkFILEWStream file(filepath.c_str());
     DCHECK(file.isValid());
-    picture->serialize(&file, &EncodeBitmapToData);
+
+    PNGSerializer serializer;
+    picture->serialize(&file, &serializer);
   }
 
  private:
   base::FilePath dirpath_;
   int layer_id_;
 };
 
 template <typename T>
 bool GetArg(gin::Arguments* args, T* value) {
   if (!args->GetNext(value)) {
@@ skipping 690 matching lines @@
 
   return context.compositor()->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
 bool GpuBenchmarking::HasGpuProcess() {
     GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
     return !!gpu_channel;
 }
 
 }  // namespace content