Add raster timing to ImageDecodeBench

third_party/WebKit/Source/platform/testing/ImageDecodeBench.cpp

 // Copyright 2015 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.
 
 // Provides a minimal wrapping of the Blink image decoders. Used to perform
 // a non-threaded, memory-to-memory image decode using micro second accuracy
 // clocks to measure image decode time. Optionally applies color correction
 // during image decoding on supported platforms (default off). Usage:
 //
 //   % ninja -C out/Release image_decode_bench &&
@@ skipping 14 matching lines @@
 // to http://crbug.com/398235#c103 and http://crbug.com/258324#c5
 
 #include <memory>
 #include <vector>
 #include "base/command_line.h"
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/test/icc_profiles.h"
 
 #if defined(_WIN32)
 #include <mmsystem.h>
 #include <sys/stat.h>
 #include <time.h>
 #define stat(x, y) _stat(x, y)
 typedef struct _stat sttype;
 #else
 #include <sys/stat.h>
@@ skipping 252 matching lines @@
       }
     }
 
     if (all_data_received || decoder->Failed())
       return;
   }
 
   Print2DResults(timings);
 }
 
+void TimeRaster(ImageDecoder* decoder,
+                PassRefPtr<SharedBuffer> data,
+                size_t iterations) {
+  // Force enough parsing to later determine the image's size.

[scroggo_chromium, 2017/05/22 12:50:14]

I find this comment confusing. Calling FrameBufferAtIndex(0) parses enough to
determine the size immediately. If you only want the size, you can call

  if (decoder->IsSizeAvailable()) {
    size = decoder->Size();
  }

That said, if the size is not available, you probably do not want to continue
anyway, so this could be:

  if (!decoder->IsSizeAvailable()) {
    printf("failed to decode\n");
    return;
  }

  const auto size = decoder->Size();

What should we do if the decode fails? We've already ensured that there is a
valid size, but it could still fail during parsing, before we decode anything,
in which case I think FrameBufferAtIndex will not actually decode anything. It
could also fail during decode, in which case we probably don't want to time it.
Then the frame will be FramePartial, but since it's guaranteed to have
transparent pixels (and be treated that way), I don't think it makes sense to
time for the comparison we want.

[cblume, 2017/05/22 21:33:02]

Done.

I think you are right that if we don't have FrameComplete we don't want to
continue with the timing. I'll do a similar error-on-failure if the first frame
could not be completely decoded.

+  const bool all_data_received = true;
+  decoder->SetData(data.Get(), all_data_received);
+  ImageFrame* frame = decoder->FrameBufferAtIndex(0);
+
+  const auto size = decoder->Size();
+  auto surface = SkSurface::MakeRasterN32Premul(size.Width(), size.Height());
+  auto canvas = surface->getCanvas();
+
+  std::vector<double> timings(iterations);
+  for (size_t iteration = 0; iteration < iterations; ++iteration) {

[scroggo_chromium, 2017/05/22 12:50:14]

nit: I would change "iteration" to "i". It makes it much easier to read this
line.

[cblume, 2017/05/22 21:33:02]

Done.

+    double start_time = GetCurrentTime();
+    canvas->drawBitmap(frame->Bitmap(), 0, 0, nullptr);
+    double elapsed_time = GetCurrentTime() - start_time;
+    timings[iteration] = elapsed_time;
+  }
+
+  for (double iteration_time : timings) {
+    printf("%f,\n", iteration_time);
+  }
+  printf("\n");
+}
+
 }  // namespace
 
 int Main(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
 
   // If the platform supports color correction, allow it to be controlled.
 
   bool apply_color_correction = false;
   if (argc >= 2 && strcmp(argv[1], "--color-correct") == 0) {
     --argc;
@@ skipping 71 matching lines @@
   }
 
   return 0;
 }
 
 }  // namespace blink
 
 int main(int argc, char* argv[]) {
   return blink::Main(argc, argv);
 }