1 files changed, 68 insertions, 129 deletions

diff --git a/Source/WebKit/android/jni/ViewStateSerializer.cpp b/Source/WebKit/android/jni/ViewStateSerializer.cpp
index 02ddca6..6b473f5 100644
--- a/Source/WebKit/android/jni/ViewStateSerializer.cpp
+++ b/Source/WebKit/android/jni/ViewStateSerializer.cpp
@@ -23,23 +23,15 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#define LOG_TAG "ViewStateSerializer"
-#define LOG_NDEBUG 1
-
 #include "config.h"
 
 #include "BaseLayerAndroid.h"
 #include "CreateJavaOutputStreamAdaptor.h"
-#include "FixedPositioning.h"
 #include "ImagesManager.h"
-#include "IFrameContentLayerAndroid.h"
-#include "IFrameLayerAndroid.h"
 #include "Layer.h"
 #include "LayerAndroid.h"
-#include "LayerContent.h"
-#include "PictureLayerContent.h"
+#include "PictureSet.h"
 #include "ScrollableLayerAndroid.h"
-#include "SkFlattenable.h"
 #include "SkPicture.h"
 #include "TilesManager.h"
 
@@ -47,13 +39,24 @@
 #include <JNIHelp.h>
 #include <jni.h>
 
+#ifdef DEBUG
+
+#undef XLOG
+#define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "ViewStateSerializer", __VA_ARGS__)
+
+#else
+
+#undef XLOG
+#define XLOG(...)
+
+#endif // DEBUG
+
 namespace android {
 
 enum LayerTypes {
     LTNone = 0,
     LTLayerAndroid = 1,
     LTScrollableLayerAndroid = 2,
-    LTFixedLayerAndroid = 3
 };
 
 static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer,
@@ -69,14 +72,16 @@ static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer,
 #else
     stream->write32(0);
 #endif
+    SkPicture picture;
+    PictureSet* content = baseLayer->content();
+    baseLayer->drawCanvas(picture.beginRecording(content->width(), content->height(),
+            SkPicture::kUsePathBoundsForClip_RecordingFlag));
+    picture.endRecording();
     if (!stream)
         return false;
-    if (baseLayer->content())
-        baseLayer->content()->serialize(stream);
-    else
-        return false;
+    picture.serialize(stream);
     int childCount = baseLayer->countChildren();
-    ALOGV("BaseLayer has %d child(ren)", childCount);
+    XLOG("BaseLayer has %d child(ren)", childCount);
     stream->write32(childCount);
     for (int i = 0; i < childCount; i++) {
         LayerAndroid* layer = static_cast<LayerAndroid*>(baseLayer->getChild(i));
@@ -86,28 +91,23 @@ static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer,
     return true;
 }
 
-static BaseLayerAndroid* nativeDeserializeViewState(JNIEnv* env, jobject, jint version,
-                                                    jobject jstream, jbyteArray jstorage)
+static BaseLayerAndroid* nativeDeserializeViewState(JNIEnv* env, jobject, jobject jstream,
+                                      jbyteArray jstorage)
 {
     SkStream* stream = CreateJavaInputStreamAdaptor(env, jstream, jstorage);
     if (!stream)
         return 0;
+    BaseLayerAndroid* layer = new BaseLayerAndroid();
     Color color = stream->readU32();
-    SkPicture* picture = new SkPicture(stream);
-    PictureLayerContent* content = new PictureLayerContent(picture);
-
-    BaseLayerAndroid* layer = new BaseLayerAndroid(content);
+#if USE(ACCELERATED_COMPOSITING)
     layer->setBackgroundColor(color);
-
-    SkRegion dirtyRegion;
-    dirtyRegion.setRect(0, 0, content->width(), content->height());
-    layer->markAsDirty(dirtyRegion);
-
-    SkSafeUnref(content);
+#endif
+    SkPicture* picture = new SkPicture(stream);
+    layer->setContent(picture);
     SkSafeUnref(picture);
     int childCount = stream->readS32();
     for (int i = 0; i < childCount; i++) {
-        LayerAndroid* childLayer = deserializeLayer(version, stream);
+        LayerAndroid* childLayer = deserializeLayer(stream);
         if (childLayer)
             layer->addChild(childLayer);
     }
@@ -242,20 +242,20 @@ void readTransformationMatrix(SkStream *stream, TransformationMatrix& matrix)
 void serializeLayer(LayerAndroid* layer, SkWStream* stream)
 {
     if (!layer) {
-        ALOGV("NULL layer!");
+        XLOG("NULL layer!");
         stream->write8(LTNone);
         return;
     }
     if (layer->isMedia() || layer->isVideo()) {
-        ALOGV("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
+        XLOG("Layer isn't supported for serialization: isMedia: %s, isVideo: %s",
              layer->isMedia() ? "true" : "false",
              layer->isVideo() ? "true" : "false");
         stream->write8(LTNone);
         return;
     }
-    LayerTypes type = LTLayerAndroid;
-    if (layer->contentIsScrollable())
-        type = LTScrollableLayerAndroid;
+    LayerTypes type = layer->contentIsScrollable()
+            ? LTScrollableLayerAndroid
+            : LTLayerAndroid;
     stream->write8(type);
 
     // Start with Layer fields
@@ -272,43 +272,20 @@ void serializeLayer(LayerAndroid* layer, SkWStream* stream)
 
     // Next up, LayerAndroid fields
     stream->writeBool(layer->m_haveClip);
-    stream->writeBool(layer->isPositionFixed());
+    stream->writeBool(layer->m_isFixed);
     stream->writeBool(layer->m_backgroundColorSet);
-    stream->writeBool(layer->isIFrame());
-
-    // With the current LayerAndroid hierarchy, LayerAndroid doesn't have
-    // those fields anymore. Let's keep the current serialization format for
-    // now and output blank fields... not great, but probably better than
-    // dealing with multiple versions.
-    if (layer->fixedPosition()) {
-        FixedPositioning* fixedPosition = layer->fixedPosition();
-        writeSkLength(stream, fixedPosition->m_fixedLeft);
-        writeSkLength(stream, fixedPosition->m_fixedTop);
-        writeSkLength(stream, fixedPosition->m_fixedRight);
-        writeSkLength(stream, fixedPosition->m_fixedBottom);
-        writeSkLength(stream, fixedPosition->m_fixedMarginLeft);
-        writeSkLength(stream, fixedPosition->m_fixedMarginTop);
-        writeSkLength(stream, fixedPosition->m_fixedMarginRight);
-        writeSkLength(stream, fixedPosition->m_fixedMarginBottom);
-        writeSkRect(stream, fixedPosition->m_fixedRect);
-        stream->write32(fixedPosition->m_renderLayerPos.x());
-        stream->write32(fixedPosition->m_renderLayerPos.y());
-    } else {
-        SkLength length;
-        SkRect rect;
-        writeSkLength(stream, length); // fixedLeft
-        writeSkLength(stream, length); // fixedTop
-        writeSkLength(stream, length); // fixedRight
-        writeSkLength(stream, length); // fixedBottom
-        writeSkLength(stream, length); // fixedMarginLeft
-        writeSkLength(stream, length); // fixedMarginTop
-        writeSkLength(stream, length); // fixedMarginRight
-        writeSkLength(stream, length); // fixedMarginBottom
-        writeSkRect(stream, rect);     // fixedRect
-        stream->write32(0);            // renderLayerPos.x()
-        stream->write32(0);            // renderLayerPos.y()
-    }
-
+    stream->writeBool(layer->m_isIframe);
+    writeSkLength(stream, layer->m_fixedLeft);
+    writeSkLength(stream, layer->m_fixedTop);
+    writeSkLength(stream, layer->m_fixedRight);
+    writeSkLength(stream, layer->m_fixedBottom);
+    writeSkLength(stream, layer->m_fixedMarginLeft);
+    writeSkLength(stream, layer->m_fixedMarginTop);
+    writeSkLength(stream, layer->m_fixedMarginRight);
+    writeSkLength(stream, layer->m_fixedMarginBottom);
+    writeSkRect(stream, layer->m_fixedRect);
+    stream->write32(layer->m_renderLayerPos.x());
+    stream->write32(layer->m_renderLayerPos.y());
     stream->writeBool(layer->m_backfaceVisibility);
     stream->writeBool(layer->m_visible);
     stream->write32(layer->m_backgroundColor);
@@ -328,10 +305,10 @@ void serializeLayer(LayerAndroid* layer, SkWStream* stream)
         stream->write32(buffer.size());
         buffer.writeToStream(stream);
     }
-    bool hasRecordingPicture = layer->m_content != 0 && !layer->m_content->isEmpty();
+    bool hasRecordingPicture = layer->m_recordingPicture != 0;
     stream->writeBool(hasRecordingPicture);
     if (hasRecordingPicture)
-        layer->m_content->serialize(stream);
+        layer->m_recordingPicture->serialize(stream);
     // TODO: support m_animations (maybe?)
     stream->write32(0); // placeholder for m_animations.size();
     writeTransformationMatrix(stream, layer->m_transform);
@@ -350,7 +327,7 @@ void serializeLayer(LayerAndroid* layer, SkWStream* stream)
         serializeLayer(layer->getChild(i), stream);
 }
 
-LayerAndroid* deserializeLayer(int version, SkStream* stream)
+LayerAndroid* deserializeLayer(SkStream* stream)
 {
     int type = stream->readU8();
     if (type == LTNone)
@@ -362,7 +339,7 @@ LayerAndroid* deserializeLayer(int version, SkStream* stream)
     else if (type == LTScrollableLayerAndroid)
         layer = new ScrollableLayerAndroid((RenderLayer*) 0);
     else {
-        ALOGV("Unexpected layer type: %d, aborting!", type);
+        XLOG("Unexpected layer type: %d, aborting!", type);
         return 0;
     }
 
@@ -377,55 +354,20 @@ LayerAndroid* deserializeLayer(int version, SkStream* stream)
 
     // LayerAndroid fields
     layer->m_haveClip = stream->readBool();
-
-    // Keep the legacy serialization/deserialization format...
-    bool isFixed = stream->readBool();
-
+    layer->m_isFixed = stream->readBool();
     layer->m_backgroundColorSet = stream->readBool();
-
-    bool isIframe = stream->readBool();
-    // If we are a scrollable layer android, we are an iframe content
-    if (isIframe && type == LTScrollableLayerAndroid) {
-         IFrameContentLayerAndroid* iframeContent = new IFrameContentLayerAndroid(*layer);
-         layer->unref();
-         layer = iframeContent;
-    } else if (isIframe) { // otherwise we are just the iframe (we use it to compute offset)
-         IFrameLayerAndroid* iframe = new IFrameLayerAndroid(*layer);
-         layer->unref();
-         layer = iframe;
-    }
-
-    if (isFixed) {
-        FixedPositioning* fixedPosition = new FixedPositioning(layer);
-
-        fixedPosition->m_fixedLeft = readSkLength(stream);
-        fixedPosition->m_fixedTop = readSkLength(stream);
-        fixedPosition->m_fixedRight = readSkLength(stream);
-        fixedPosition->m_fixedBottom = readSkLength(stream);
-        fixedPosition->m_fixedMarginLeft = readSkLength(stream);
-        fixedPosition->m_fixedMarginTop = readSkLength(stream);
-        fixedPosition->m_fixedMarginRight = readSkLength(stream);
-        fixedPosition->m_fixedMarginBottom = readSkLength(stream);
-        fixedPosition->m_fixedRect = readSkRect(stream);
-        fixedPosition->m_renderLayerPos.setX(stream->readS32());
-        fixedPosition->m_renderLayerPos.setY(stream->readS32());
-
-        layer->setFixedPosition(fixedPosition);
-    } else {
-        // Not a fixed element, bypass the values in the stream
-        readSkLength(stream); // fixedLeft
-        readSkLength(stream); // fixedTop
-        readSkLength(stream); // fixedRight
-        readSkLength(stream); // fixedBottom
-        readSkLength(stream); // fixedMarginLeft
-        readSkLength(stream); // fixedMarginTop
-        readSkLength(stream); // fixedMarginRight
-        readSkLength(stream); // fixedMarginBottom
-        readSkRect(stream);   // fixedRect
-        stream->readS32();    // renderLayerPos.x()
-        stream->readS32();    // renderLayerPos.y()
-    }
-
+    layer->m_isIframe = stream->readBool();
+    layer->m_fixedLeft = readSkLength(stream);
+    layer->m_fixedTop = readSkLength(stream);
+    layer->m_fixedRight = readSkLength(stream);
+    layer->m_fixedBottom = readSkLength(stream);
+    layer->m_fixedMarginLeft = readSkLength(stream);
+    layer->m_fixedMarginTop = readSkLength(stream);
+    layer->m_fixedMarginRight = readSkLength(stream);
+    layer->m_fixedMarginBottom = readSkLength(stream);
+    layer->m_fixedRect = readSkRect(stream);
+    layer->m_renderLayerPos.setX(stream->readS32());
+    layer->m_renderLayerPos.setY(stream->readS32());
     layer->m_backfaceVisibility = stream->readBool();
     layer->m_visible = stream->readBool();
     layer->m_backgroundColor = stream->readU32();
@@ -446,11 +388,7 @@ LayerAndroid* deserializeLayer(int version, SkStream* stream)
     }
     bool hasRecordingPicture = stream->readBool();
     if (hasRecordingPicture) {
-        SkPicture* picture = new SkPicture(stream);
-        PictureLayerContent* content = new PictureLayerContent(picture);
-        layer->setContent(content);
-        SkSafeUnref(content);
-        SkSafeUnref(picture);
+        layer->m_recordingPicture = new SkPicture(stream);
     }
     int animationCount = stream->readU32(); // TODO: Support (maybe?)
     readTransformationMatrix(stream, layer->m_transform);
@@ -466,11 +404,12 @@ LayerAndroid* deserializeLayer(int version, SkStream* stream)
     }
     int childCount = stream->readU32();
     for (int i = 0; i < childCount; i++) {
-        LayerAndroid *childLayer = deserializeLayer(version, stream);
+        LayerAndroid *childLayer = deserializeLayer(stream);
         if (childLayer)
             layer->addChild(childLayer);
     }
-    ALOGV("Created layer with id %d", layer->uniqueId());
+    layer->needsRepaint();
+    XLOG("Created layer with id %d", layer->uniqueId());
     return layer;
 }
 
@@ -480,7 +419,7 @@ LayerAndroid* deserializeLayer(int version, SkStream* stream)
 static JNINativeMethod gSerializerMethods[] = {
     { "nativeSerializeViewState", "(ILjava/io/OutputStream;[B)Z",
         (void*) nativeSerializeViewState },
-    { "nativeDeserializeViewState", "(ILjava/io/InputStream;[B)I",
+    { "nativeDeserializeViewState", "(Ljava/io/InputStream;[B)I",
         (void*) nativeDeserializeViewState },
 };