DevTools: Add snapshot command log on the frontend.

Source/platform/graphics/GraphicsContextRecorder.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 146 matching lines @@
         return false;
     }
 
     const GraphicsContextSnapshot::Timings& timingsVector() const { return *m_timingsVector; }
 
 private:
     GraphicsContextSnapshot::Timings* m_timingsVector;
     Vector<double>* m_currentTimings;
 };
 
-class LoggingSnapshotPlayer : public SnapshotPlayer {
-public:
-    LoggingSnapshotPlayer(PassRefPtr<SkPicture> picture, SkCanvas* canvas)
-        : SnapshotPlayer(picture, canvas)
-    {
-    }
-
-    virtual bool abortDrawing() OVERRIDE
-    {
-        return false;
-    }
-};
-
 class LoggingCanvas : public SkCanvas {
 public:
-    LoggingCanvas()
+    LoggingCanvas(int width, int height) : SkCanvas(width, height)
+    {
+        initLog();
+    }
+
+    void initLog()
     {
         m_log = JSONArray::create();
     }
 
     void clear(SkColor color) OVERRIDE
     {
         addItemWithParams("clear")->setString("color", stringForSkColor(color));
     }
 
     void drawPaint(const SkPaint& paint) OVERRIDE
@@ skipping 228 matching lines @@
 
     void willRestore() OVERRIDE
     {
         addItem("restore");
         this->SkCanvas::willRestore();
     }
 
     SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) OVERRIDE
     {
         RefPtr<JSONObject> params = addItemWithParams("saveLayer");
-        params->setObject("bounds", objectForSkRect(*bounds));
+        if (bounds)
+            params->setObject("bounds", objectForSkRect(*bounds));
         params->setObject("paint", objectForSkPaint(*paint));
         params->setString("saveFlags", saveFlagsToString(flags));
         this->SkCanvas::willSaveLayer(bounds, paint, flags);
         return kNoLayer_SaveLayerStrategy;
     }
 
     void willSave(SaveFlags flags) OVERRIDE
     {
         RefPtr<JSONObject> params = addItemWithParams("save");
         params->setString("saveFlags", saveFlagsToString(flags));
@@ skipping 539 matching lines @@
             paint.glyphsToUnichars(static_cast<const uint16_t*>(text), byteLength / 2, textData);
             return WTF::UTF32LittleEndianEncoding().decode(reinterpret_cast<const char*>(textData), byteLength * 2);
         }
         default:
             ASSERT_NOT_REACHED();
             return "?";
         }
     }
 };
 
+class LoggingSnapshotPlayer : public SnapshotPlayer {
+public:
+    LoggingSnapshotPlayer(PassRefPtr<SkPicture> picture, LoggingCanvas* canvas)
+        : SnapshotPlayer(picture, canvas)
+    {
+    }
+
+    void play(unsigned fromStep, unsigned toStep)
+    {
+        m_fromStep = fromStep;
+        m_toStep = toStep;
+        m_stepCount = 0;
+        SnapshotPlayer::play();
+    }
+
+    virtual bool abortDrawing() OVERRIDE
+    {
+        ++m_stepCount;
+        if (m_stepCount == m_fromStep) {
+            static_cast<LoggingCanvas*>(canvas())->initLog();
+        }
+        return m_toStep && m_stepCount > m_toStep;
+    }
+
+private:
+    unsigned m_fromStep;
+    unsigned m_toStep;
+    unsigned m_stepCount;
+};
+
 static bool decodeBitmap(const void* data, size_t length, SkBitmap* result)
 {
     RefPtr<SharedBuffer> buffer = SharedBuffer::create(static_cast<const char*>(data), length);
     OwnPtr<ImageDecoder> imageDecoder = ImageDecoder::create(*buffer, ImageSource::AlphaPremultiplied, ImageSource::GammaAndColorProfileIgnored);
     if (!imageDecoder)
         return false;
     imageDecoder->setData(buffer.get(), true);
     ImageFrame* frame = imageDecoder->frameBufferAtIndex(0);
     if (!frame)
         return true;
@@ skipping 25 matching lines @@
     ProfilingSnapshotPlayer player(m_picture, imageBuffer->context()->canvas());
     player.play(timings.get(), minRepeatCount, minDuration);
     return timings.release();
 }
 
 PassOwnPtr<ImageBuffer> GraphicsContextSnapshot::createImageBuffer() const
 {
     return ImageBuffer::create(IntSize(m_picture->width(), m_picture->height()), m_isCertainlyOpaque ? Opaque : NonOpaque);
 }
 
-PassRefPtr<JSONArray> GraphicsContextSnapshot::snapshotCommandLog() const
+PassRefPtr<JSONArray> GraphicsContextSnapshot::snapshotCommandLog(unsigned fromStep, unsigned toStep) const
 {
-    LoggingCanvas canvas;
-    FragmentSnapshotPlayer player(m_picture, &canvas);
-    player.play(0, 0);
+    LoggingCanvas canvas(m_picture->width(), m_picture->height());
+    LoggingSnapshotPlayer player(m_picture, &canvas);
+    player.play(fromStep, toStep);
     return canvas.log();
 }
 
 }