SaveViewState その３
2274 private void saveViewState(OutputStream stream, 2275 ValueCallback<Boolean> callback) { 2276 // TODO: Create a native method to do this better without overloading 2277 // the draw path (and fix saving <canvas&>) 2278 DrawData draw = new DrawData(); ＜＝８ 2279 if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "saveViewState start"); 2280 draw.mBaseLayer = nativeRecordContent(mNativeClass, draw.mContentSize); ＝＞１０へ 2281 boolean result = false; 2282 try { 2283 result = ViewStateSerializer.serializeViewState(stream, draw); ＝＞あ 2284 } catch (Throwable t) { 2285 Log.w(LOGTAG, "Failed to save view state", t); 2286 } 2287 callback.onReceiveValue(result); 2288 if (draw.mBaseLayer != 0) { 2289 if (mDrawIsScheduled) { 2290 mDrawIsScheduled = false; 2291 mEventHub.removeMessages(EventHub.WEBKIT_DRAW); 2292 } 2293 mLastDrawData = draw; 2294 webkitDraw(draw); 2295 } 2296 }
あ：
31 class ViewStateSerializer { 32 33 private static final int WORKING_STREAM_STORAGE = 16 * 1024; 34 35 static final int VERSION = 1; 36 37 static boolean serializeViewState(OutputStream stream, DrawData draw) 38 throws IOException { 39 int baseLayer = draw.mBaseLayer; 40 if (baseLayer == 0) { 41 return false; 42 } 43 DataOutputStream dos = new DataOutputStream(stream); 44 dos.writeInt(VERSION); 45 dos.writeInt(draw.mContentSize.x); 46 dos.writeInt(draw.mContentSize.y); 47 return nativeSerializeViewState(baseLayer, dos, ＝＞いへ 48 new byte[WORKING_STREAM_STORAGE]); 49 } 50 51 static DrawData deserializeViewState(InputStream stream) 52 throws IOException { 53 DataInputStream dis = new DataInputStream(stream); 54 int version = dis.readInt(); 55 if (version > VERSION) { 56 throw new IOException("Unexpected version: " + version); 57 } 58 int contentWidth = dis.readInt(); 59 int contentHeight = dis.readInt(); 60 int baseLayer = nativeDeserializeViewState(version, dis, 61 new byte[WORKING_STREAM_STORAGE]); 62 63 final WebViewCore.DrawData draw = new WebViewCore.DrawData(); 64 draw.mViewState = new WebViewCore.ViewState(); 65 draw.mContentSize = new Point(contentWidth, contentHeight); 66 draw.mBaseLayer = baseLayer; 67 stream.close(); 68 return draw; 69 }
い：
59 static bool nativeSerializeViewState(JNIEnv* env, jobject, jint jbaseLayer, 60 jobject jstream, jbyteArray jstorage) 61 { 62 BaseLayerAndroid* baseLayer = (BaseLayerAndroid*) jbaseLayer; 63 if (!baseLayer) 64 return false; 65 66 SkWStream *stream = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); 67 #if USE(ACCELERATED_COMPOSITING) 68 stream->write32(baseLayer->getBackgroundColor().rgb()); 69 #else 70 stream->write32(0); 71 #endif 72 if (!stream) 73 return false; 74 if (baseLayer->content()) 75 baseLayer->content()->serialize(stream); 76 else 77 return false; 78 int childCount = baseLayer->countChildren(); 79 ALOGV("BaseLayer has %d child(ren)", childCount); 80 stream->write32(childCount); 81 for (int i = 0; i < childCount; i++) { 82 LayerAndroid* layer = static_cast<LayerAndroid*>(baseLayer->getChild(i)); 83 serializeLayer(layer, stream); ＝＞ うへ 84 } 85 delete stream; 86 return true; 87 } 88 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ 89 static BaseLayerAndroid* nativeDeserializeViewState(JNIEnv* env, jobject, jint version, 90 jobject jstream, jbyteArray jstorage) 91 { 92 SkStream* stream = CreateJavaInputStreamAdaptor(env, jstream, jstorage); 93 if (!stream) 94 return 0; 95 Color color = stream->readU32(); 96 SkPicture* picture = new SkPicture(stream); 97 PictureLayerContent* content = new PictureLayerContent(picture); 98 99 BaseLayerAndroid* layer = new BaseLayerAndroid(content); 100 layer->setBackgroundColor(color); 101 102 SkRegion dirtyRegion; 103 dirtyRegion.setRect(0, 0, content->width(), content->height()); 104 layer->markAsDirty(dirtyRegion); 105 106 SkSafeUnref(content); 107 SkSafeUnref(picture); 108 int childCount = stream->readS32(); 109 for (int i = 0; i < childCount; i++) { 110 LayerAndroid* childLayer = deserializeLayer(version, stream); 111 if (childLayer) 112 layer->addChild(childLayer); 113 } 114 delete stream; 115 return layer; 116 } 117
Cross Reference: /external/webkit/Source/WebCore/platform/graphics/android/layers/LayerAndroid.h
#if USE(ACCELERATED_COMPOSITING)
う：
242 void serializeLayer(LayerAndroid* layer, SkWStream* stream) 243 { 244 if (!layer) { 245 ALOGV("NULL layer!"); 246 stream->write8(LTNone); 247 return; 248 } 249 if (layer->isMedia() || layer->isVideo()) { 250 ALOGV("Layer isn't supported for serialization: isMedia: %s, isVideo: %s", 251 layer->isMedia() ? "true" : "false", 252 layer->isVideo() ? "true" : "false"); 253 stream->write8(LTNone); 254 return; 255 } 256 LayerTypes type = LTLayerAndroid; 257 if (layer->contentIsScrollable()) 258 type = LTScrollableLayerAndroid; 259 stream->write8(type); 260 261 // Start with Layer fields 262 stream->writeBool(layer->shouldInheritFromRootTransform()); 263 stream->writeScalar(layer->getOpacity()); 264 stream->writeScalar(layer->getSize().width()); 265 stream->writeScalar(layer->getSize().height()); 266 stream->writeScalar(layer->getPosition().x()); 267 stream->writeScalar(layer->getPosition().y()); 268 stream->writeScalar(layer->getAnchorPoint().x()); 269 stream->writeScalar(layer->getAnchorPoint().y()); 270 writeMatrix(stream, layer->getMatrix()); 271 writeMatrix(stream, layer->getChildrenMatrix()); 272 273 // Next up, LayerAndroid fields 274 stream->writeBool(layer->m_haveClip); 275 stream->writeBool(layer->isPositionFixed()); 276 stream->writeBool(layer->m_backgroundColorSet); 277 stream->writeBool(layer->isIFrame()); 278 279 // With the current LayerAndroid hierarchy, LayerAndroid doesn't have 280 // those fields anymore. Let's keep the current serialization format for 281 // now and output blank fields... not great, but probably better than 282 // dealing with multiple versions. 283 if (layer->fixedPosition()) { 284 FixedPositioning* fixedPosition = layer->fixedPosition(); 285 writeSkLength(stream, fixedPosition->m_fixedLeft); 286 writeSkLength(stream, fixedPosition->m_fixedTop); 287 writeSkLength(stream, fixedPosition->m_fixedRight); 288 writeSkLength(stream, fixedPosition->m_fixedBottom); 289 writeSkLength(stream, fixedPosition->m_fixedMarginLeft); 290 writeSkLength(stream, fixedPosition->m_fixedMarginTop); 291 writeSkLength(stream, fixedPosition->m_fixedMarginRight); 292 writeSkLength(stream, fixedPosition->m_fixedMarginBottom); 293 writeSkRect(stream, fixedPosition->m_fixedRect); 294 stream->write32(fixedPosition->m_renderLayerPos.x()); 295 stream->write32(fixedPosition->m_renderLayerPos.y()); 296 } else { 297 SkLength length; 298 SkRect rect; 299 writeSkLength(stream, length); // fixedLeft 300 writeSkLength(stream, length); // fixedTop 301 writeSkLength(stream, length); // fixedRight 302 writeSkLength(stream, length); // fixedBottom 303 writeSkLength(stream, length); // fixedMarginLeft 304 writeSkLength(stream, length); // fixedMarginTop 305 writeSkLength(stream, length); // fixedMarginRight 306 writeSkLength(stream, length); // fixedMarginBottom 307 writeSkRect(stream, rect); // fixedRect 308 stream->write32(0); // renderLayerPos.x() 309 stream->write32(0); // renderLayerPos.y() 310 } 311 312 stream->writeBool(layer->m_backfaceVisibility); 313 stream->writeBool(layer->m_visible); 314 stream->write32(layer->m_backgroundColor); 315 stream->writeBool(layer->m_preserves3D); 316 stream->writeScalar(layer->m_anchorPointZ); 317 stream->writeScalar(layer->m_drawOpacity); 318 bool hasContentsImage = layer->m_imageCRC != 0; 319 stream->writeBool(hasContentsImage); 320 if (hasContentsImage) { 321 SkFlattenableWriteBuffer buffer(1024); 322 buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag); 323 ImageTexture* imagetexture = 324 ImagesManager::instance()->retainImage(layer->m_imageCRC); 325 if (imagetexture && imagetexture->bitmap()) 326 imagetexture->bitmap()->flatten(buffer); 327 ImagesManager::instance()->releaseImage(layer->m_imageCRC); 328 stream->write32(buffer.size()); 329 buffer.writeToStream(stream); 330 } 331 bool hasRecordingPicture = layer->m_content != 0 && !layer->m_content->isEmpty(); 332 stream->writeBool(hasRecordingPicture); 333 if (hasRecordingPicture) 334 layer->m_content->serialize(stream); 335 // TODO: support m_animations (maybe?) 336 stream->write32(0); // placeholder for m_animations.size(); 337 writeTransformationMatrix(stream, layer->m_transform); 338 writeTransformationMatrix(stream, layer->m_childrenTransform); 339 if (type == LTScrollableLayerAndroid) { 340 ScrollableLayerAndroid* scrollableLayer = 341 static_cast<ScrollableLayerAndroid*>(layer); 342 stream->writeScalar(scrollableLayer->m_scrollLimits.fLeft); 343 stream->writeScalar(scrollableLayer->m_scrollLimits.fTop); 344 stream->writeScalar(scrollableLayer->m_scrollLimits.width()); 345 stream->writeScalar(scrollableLayer->m_scrollLimits.height()); 346 } 347 int childCount = layer->countChildren(); 348 stream->write32(childCount); 349 for (int i = 0; i < childCount; i++) 350 serializeLayer(layer->getChild(i), stream); 351 } 352 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ 353 LayerAndroid* deserializeLayer(int version, SkStream* stream) 354 { 355 int type = stream->readU8(); 356 if (type == LTNone) 357 return 0; 358 // Cast is to disambiguate between ctors. 359 LayerAndroid *layer; 360 if (type == LTLayerAndroid) 361 layer = new LayerAndroid((RenderLayer*) 0); 362 else if (type == LTScrollableLayerAndroid) 363 layer = new ScrollableLayerAndroid((RenderLayer*) 0); 364 else { 365 ALOGV("Unexpected layer type: %d, aborting!", type); 366 return 0; 367 } 368 369 // Layer fields 370 layer->setShouldInheritFromRootTransform(stream->readBool()); 371 layer->setOpacity(stream->readScalar()); 372 layer->setSize(stream->readScalar(), stream->readScalar()); 373 layer->setPosition(stream->readScalar(), stream->readScalar()); 374 layer->setAnchorPoint(stream->readScalar(), stream->readScalar()); 375 layer->setMatrix(readMatrix(stream)); 376 layer->setChildrenMatrix(readMatrix(stream)); 377 378 // LayerAndroid fields 379 layer->m_haveClip = stream->readBool(); 380 381 // Keep the legacy serialization/deserialization format... 382 bool isFixed = stream->readBool(); 383 384 layer->m_backgroundColorSet = stream->readBool(); 385 386 bool isIframe = stream->readBool(); 387 // If we are a scrollable layer android, we are an iframe content 388 if (isIframe && type == LTScrollableLayerAndroid) { 389 IFrameContentLayerAndroid* iframeContent = new IFrameContentLayerAndroid(*layer); 390 layer->unref(); 391 layer = iframeContent; 392 } else if (isIframe) { // otherwise we are just the iframe (we use it to compute offset) 393 IFrameLayerAndroid* iframe = new IFrameLayerAndroid(*layer); 394 layer->unref(); 395 layer = iframe; 396 } 397 398 if (isFixed) { 399 FixedPositioning* fixedPosition = new FixedPositioning(layer); 400 401 fixedPosition->m_fixedLeft = readSkLength(stream); 402 fixedPosition->m_fixedTop = readSkLength(stream); 403 fixedPosition->m_fixedRight = readSkLength(stream); 404 fixedPosition->m_fixedBottom = readSkLength(stream); 405 fixedPosition->m_fixedMarginLeft = readSkLength(stream); 406 fixedPosition->m_fixedMarginTop = readSkLength(stream); 407 fixedPosition->m_fixedMarginRight = readSkLength(stream); 408 fixedPosition->m_fixedMarginBottom = readSkLength(stream); 409 fixedPosition->m_fixedRect = readSkRect(stream); 410 fixedPosition->m_renderLayerPos.setX(stream->readS32()); 411 fixedPosition->m_renderLayerPos.setY(stream->readS32()); 412 413 layer->setFixedPosition(fixedPosition); 414 } else { 415 // Not a fixed element, bypass the values in the stream 416 readSkLength(stream); // fixedLeft 417 readSkLength(stream); // fixedTop 418 readSkLength(stream); // fixedRight 419 readSkLength(stream); // fixedBottom 420 readSkLength(stream); // fixedMarginLeft 421 readSkLength(stream); // fixedMarginTop 422 readSkLength(stream); // fixedMarginRight 423 readSkLength(stream); // fixedMarginBottom 424 readSkRect(stream); // fixedRect 425 stream->readS32(); // renderLayerPos.x() 426 stream->readS32(); // renderLayerPos.y() 427 } 428 429 layer->m_backfaceVisibility = stream->readBool(); 430 layer->m_visible = stream->readBool(); 431 layer->m_backgroundColor = stream->readU32(); 432 layer->m_preserves3D = stream->readBool(); 433 layer->m_anchorPointZ = stream->readScalar(); 434 layer->m_drawOpacity = stream->readScalar(); 435 bool hasContentsImage = stream->readBool(); 436 if (hasContentsImage) { 437 int size = stream->readU32(); 438 SkAutoMalloc storage(size); 439 stream->read(storage.get(), size); 440 SkFlattenableReadBuffer buffer(storage.get(), size); 441 SkBitmap contentsImage; 442 contentsImage.unflatten(buffer); 443 SkBitmapRef* imageRef = new SkBitmapRef(contentsImage); 444 layer->setContentsImage(imageRef); 445 delete imageRef; 446 } 447 bool hasRecordingPicture = stream->readBool(); 448 if (hasRecordingPicture) { 449 SkPicture* picture = new SkPicture(stream); 450 PictureLayerContent* content = new PictureLayerContent(picture); 451 layer->setContent(content); 452 SkSafeUnref(content); 453 SkSafeUnref(picture); 454 } 455 int animationCount = stream->readU32(); // TODO: Support (maybe?) 456 readTransformationMatrix(stream, layer->m_transform); 457 readTransformationMatrix(stream, layer->m_childrenTransform); 458 if (type == LTScrollableLayerAndroid) { 459 ScrollableLayerAndroid* scrollableLayer = 460 static_cast<ScrollableLayerAndroid*>(layer); 461 scrollableLayer->m_scrollLimits.set( 462 stream->readScalar(), 463 stream->readScalar(), 464 stream->readScalar(), 465 stream->readScalar()); 466 } 467 int childCount = stream->readU32(); 468 for (int i = 0; i < childCount; i++) { 469 LayerAndroid *childLayer = deserializeLayer(version, stream); 470 if (childLayer) 471 layer->addChild(childLayer); 472 } 473 ALOGV("Created layer with id %d", layer->uniqueId()); 474 return layer; 475 }
