gfx/2d/RecordedEvent.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "RecordedEvent.h"
   7 #include "PathRecording.h"
   8
   9 #include "Tools.h"
  10
  11 namespace mozilla {
  12 namespace gfx {
  13
  14 using namespace std;
  15
  16 static std::string NameFromBackend(BackendType aType)
  17 {
  18   switch (aType) {
  19   case BACKEND_NONE:
  20     return "None";
  21   case BACKEND_DIRECT2D:
  22     return "Direct2D";
  23   default:
  24     return "Unknown";
  25   }
  26 }
  27
  28 #define LOAD_EVENT_TYPE(_typeenum, _class) \
  29   case _typeenum: return new _class(aStream)
  30
  31 RecordedEvent *
  32 RecordedEvent::LoadEventFromStream(std::istream &aStream, EventType aType)
  33 {
  34   switch (aType) {
  35     LOAD_EVENT_TYPE(DRAWTARGETCREATION, RecordedDrawTargetCreation);
  36     LOAD_EVENT_TYPE(DRAWTARGETDESTRUCTION, RecordedDrawTargetDestruction);
  37     LOAD_EVENT_TYPE(FILLRECT, RecordedFillRect);
  38     LOAD_EVENT_TYPE(STROKERECT, RecordedStrokeRect);
  39     LOAD_EVENT_TYPE(STROKELINE, RecordedStrokeLine);
  40     LOAD_EVENT_TYPE(CLEARRECT, RecordedClearRect);
  41     LOAD_EVENT_TYPE(COPYSURFACE, RecordedCopySurface);
  42     LOAD_EVENT_TYPE(SETTRANSFORM, RecordedSetTransform);
  43     LOAD_EVENT_TYPE(PUSHCLIPRECT, RecordedPushClipRect);
  44     LOAD_EVENT_TYPE(PUSHCLIP, RecordedPushClip);
  45     LOAD_EVENT_TYPE(POPCLIP, RecordedPopClip);
  46     LOAD_EVENT_TYPE(FILL, RecordedFill);
  47     LOAD_EVENT_TYPE(FILLGLYPHS, RecordedFillGlyphs);
  48     LOAD_EVENT_TYPE(MASK, RecordedMask);
  49     LOAD_EVENT_TYPE(STROKE, RecordedStroke);
  50     LOAD_EVENT_TYPE(DRAWSURFACE, RecordedDrawSurface);
  51     LOAD_EVENT_TYPE(DRAWSURFACEWITHSHADOW, RecordedDrawSurfaceWithShadow);
  52     LOAD_EVENT_TYPE(PATHCREATION, RecordedPathCreation);
  53     LOAD_EVENT_TYPE(PATHDESTRUCTION, RecordedPathDestruction);
  54     LOAD_EVENT_TYPE(SOURCESURFACECREATION, RecordedSourceSurfaceCreation);
  55     LOAD_EVENT_TYPE(SOURCESURFACEDESTRUCTION, RecordedSourceSurfaceDestruction);
  56     LOAD_EVENT_TYPE(GRADIENTSTOPSCREATION, RecordedGradientStopsCreation);
  57     LOAD_EVENT_TYPE(GRADIENTSTOPSDESTRUCTION, RecordedGradientStopsDestruction);
  58     LOAD_EVENT_TYPE(SNAPSHOT, RecordedSnapshot);
  59     LOAD_EVENT_TYPE(SCALEDFONTCREATION, RecordedScaledFontCreation);
  60     LOAD_EVENT_TYPE(SCALEDFONTDESTRUCTION, RecordedScaledFontDestruction);
  61   default:
  62     return NULL;
  63   }
  64 }
  65
  66 void
  67 RecordedEvent::RecordPatternData(std::ostream &aStream, const PatternStorage &aPattern) const
  68 {
  69   WriteElement(aStream, aPattern.mType);
  70
  71   switch (aPattern.mType) {
  72   case PATTERN_COLOR:
  73     {
  74       WriteElement(aStream, *reinterpret_cast<const ColorPatternStorage*>(&aPattern.mStorage));
  75       return;
  76     }
  77   case PATTERN_LINEAR_GRADIENT:
  78     {
  79       WriteElement(aStream, *reinterpret_cast<const LinearGradientPatternStorage*>(&aPattern.mStorage));
  80       return;
  81     }
  82   case PATTERN_RADIAL_GRADIENT:
  83     {
  84       WriteElement(aStream, *reinterpret_cast<const RadialGradientPatternStorage*>(&aPattern.mStorage));
  85       return;
  86     }
  87   case PATTERN_SURFACE:
  88     {
  89       WriteElement(aStream, *reinterpret_cast<const SurfacePatternStorage*>(&aPattern.mStorage));
  90       return;
  91     }
  92   default:
  93     return;
  94   }
  95 }
  96
  97 void
  98 RecordedEvent::ReadPatternData(std::istream &aStream, PatternStorage &aPattern) const
  99 {
 100   ReadElement(aStream, aPattern.mType);
 101
 102   switch (aPattern.mType) {
 103   case PATTERN_COLOR:
 104     {
 105       ReadElement(aStream, *reinterpret_cast<ColorPatternStorage*>(&aPattern.mStorage));
 106       return;
 107     }
 108   case PATTERN_LINEAR_GRADIENT:
 109     {
 110       ReadElement(aStream, *reinterpret_cast<LinearGradientPatternStorage*>(&aPattern.mStorage));
 111       return;
 112     }
 113   case PATTERN_RADIAL_GRADIENT:
 114     {
 115       ReadElement(aStream, *reinterpret_cast<RadialGradientPatternStorage*>(&aPattern.mStorage));
 116       return;
 117     }
 118   case PATTERN_SURFACE:
 119     {
 120       ReadElement(aStream, *reinterpret_cast<SurfacePatternStorage*>(&aPattern.mStorage));
 121       return;
 122     }
 123   default:
 124     return;
 125   }
 126 }
 127
 128 void
 129 RecordedEvent::StorePattern(PatternStorage &aDestination, const Pattern &aSource) const
 130 {
 131   aDestination.mType = aSource.GetType();
 132
 133   switch (aSource.GetType()) {
 134   case PATTERN_COLOR:
 135     {
 136       reinterpret_cast<ColorPatternStorage*>(&aDestination.mStorage)->mColor =
 137         static_cast<const ColorPattern*>(&aSource)->mColor;
 138       return;
 139     }
 140   case PATTERN_LINEAR_GRADIENT:
 141     {
 142       LinearGradientPatternStorage *store =
 143         reinterpret_cast<LinearGradientPatternStorage*>(&aDestination.mStorage);
 144       const LinearGradientPattern *pat =
 145         static_cast<const LinearGradientPattern*>(&aSource);
 146       store->mBegin = pat->mBegin;
 147       store->mEnd = pat->mEnd;
 148       store->mMatrix = pat->mMatrix;
 149       store->mStops = pat->mStops.get();
 150       return;
 151     }
 152   case PATTERN_RADIAL_GRADIENT:
 153     {
 154       RadialGradientPatternStorage *store =
 155         reinterpret_cast<RadialGradientPatternStorage*>(&aDestination.mStorage);
 156       const RadialGradientPattern *pat =
 157         static_cast<const RadialGradientPattern*>(&aSource);
 158       store->mCenter1 = pat->mCenter1;
 159       store->mCenter2 = pat->mCenter2;
 160       store->mRadius1 = pat->mRadius1;
 161       store->mRadius2 = pat->mRadius2;
 162       store->mMatrix = pat->mMatrix;
 163       store->mStops = pat->mStops.get();
 164       return;
 165     }
 166   case PATTERN_SURFACE:
 167     {
 168       SurfacePatternStorage *store =
 169         reinterpret_cast<SurfacePatternStorage*>(&aDestination.mStorage);
 170       const SurfacePattern *pat =
 171         static_cast<const SurfacePattern*>(&aSource);
 172       store->mExtend = pat->mExtendMode;
 173       store->mFilter = pat->mFilter;
 174       store->mMatrix = pat->mMatrix;
 175       store->mSurface = pat->mSurface;
 176       return;
 177     }
 178   }
 179 }
 180
 181 void
 182 RecordedEvent::RecordStrokeOptions(std::ostream &aStream, const StrokeOptions &aStrokeOptions) const
 183 {
 184   JoinStyle joinStyle = aStrokeOptions.mLineJoin;
 185   CapStyle capStyle = aStrokeOptions.mLineCap;
 186
 187   WriteElement(aStream, uint64_t(aStrokeOptions.mDashLength));
 188   WriteElement(aStream, aStrokeOptions.mDashOffset);
 189   WriteElement(aStream, aStrokeOptions.mLineWidth);
 190   WriteElement(aStream, aStrokeOptions.mMiterLimit);
 191   WriteElement(aStream, joinStyle);
 192   WriteElement(aStream, capStyle);
 193
 194   if (!aStrokeOptions.mDashPattern) {
 195     return;
 196   }
 197
 198   aStream.write((char*)aStrokeOptions.mDashPattern, sizeof(Float) * aStrokeOptions.mDashLength);
 199 }
 200
 201 void
 202 RecordedEvent::ReadStrokeOptions(std::istream &aStream, StrokeOptions &aStrokeOptions)
 203 {
 204   uint64_t dashLength;
 205   JoinStyle joinStyle;
 206   CapStyle capStyle;
 207
 208   ReadElement(aStream, dashLength);
 209   ReadElement(aStream, aStrokeOptions.mDashOffset);
 210   ReadElement(aStream, aStrokeOptions.mLineWidth);
 211   ReadElement(aStream, aStrokeOptions.mMiterLimit);
 212   ReadElement(aStream, joinStyle);
 213   ReadElement(aStream, capStyle);
 214   // On 32 bit we truncate the value of dashLength.
 215   // See also bug 811850 for history.
 216   aStrokeOptions.mDashLength = size_t(dashLength);
 217   aStrokeOptions.mLineJoin = joinStyle;
 218   aStrokeOptions.mLineCap = capStyle;
 219
 220   if (!aStrokeOptions.mDashLength) {
 221     return;
 222   }
 223
 224   mDashPatternStorage.resize(aStrokeOptions.mDashLength);
 225   aStrokeOptions.mDashPattern = &mDashPatternStorage.front();
 226   aStream.read((char*)aStrokeOptions.mDashPattern, sizeof(Float) * aStrokeOptions.mDashLength);
 227 }
 228
 229 void
 230 RecordedEvent::OutputSimplePatternInfo(const PatternStorage &aStorage, std::stringstream &aOutput) const
 231 {
 232   switch (aStorage.mType) {
 233   case PATTERN_COLOR:
 234     {
 235       const Color color = reinterpret_cast<const ColorPatternStorage*>(&aStorage.mStorage)->mColor;
 236       aOutput << "Color: (" << color.r << ", " << color.g << ", " << color.b << ", " << color.a << ")";
 237       return;
 238     }
 239   case PATTERN_LINEAR_GRADIENT:
 240     {
 241       const LinearGradientPatternStorage *store =
 242         reinterpret_cast<const LinearGradientPatternStorage*>(&aStorage.mStorage);
 243
 244       aOutput << "LinearGradient (" << store->mBegin.x << ", " << store->mBegin.y <<
 245         ") - (" << store->mEnd.x << ", " << store->mEnd.y << ") Stops: " << store->mStops;
 246       return;
 247     }
 248   case PATTERN_RADIAL_GRADIENT:
 249     {
 250       const RadialGradientPatternStorage *store =
 251         reinterpret_cast<const RadialGradientPatternStorage*>(&aStorage.mStorage);
 252       aOutput << "RadialGradient (Center 1: (" << store->mCenter1.x << ", " <<
 253         store->mCenter2.y << ") Radius 2: " << store->mRadius2;
 254       return;
 255     }
 256   case PATTERN_SURFACE:
 257     {
 258       const SurfacePatternStorage *store =
 259         reinterpret_cast<const SurfacePatternStorage*>(&aStorage.mStorage);
 260       aOutput << "Surface (0x" << store->mSurface << ")";
 261       return;
 262     }
 263   }
 264 }
 265
 266 RecordedDrawingEvent::RecordedDrawingEvent(EventType aType, std::istream &aStream)
 267   : RecordedEvent(aType)
 268 {
 269   ReadElement(aStream, mDT);
 270 }
 271
 272 void
 273 RecordedDrawingEvent::RecordToStream(ostream &aStream) const
 274 {
 275   WriteElement(aStream, mDT);
 276 }
 277
 278 ReferencePtr
 279 RecordedDrawingEvent::GetObject() const
 280 {
 281   return mDT;
 282 }
 283
 284 void
 285 RecordedDrawTargetCreation::PlayEvent(Translator *aTranslator) const
 286 {
 287   RefPtr<DrawTarget> newDT =
 288     aTranslator->GetReferenceDrawTarget()->CreateSimilarDrawTarget(mSize, mFormat);
 289   aTranslator->AddDrawTarget(mRefPtr, newDT);
 290 }
 291
 292 void
 293 RecordedDrawTargetCreation::RecordToStream(ostream &aStream) const
 294 {
 295   WriteElement(aStream, mRefPtr);
 296   WriteElement(aStream, mBackendType);
 297   WriteElement(aStream, mSize);
 298   WriteElement(aStream, mFormat);
 299 }
 300
 301 RecordedDrawTargetCreation::RecordedDrawTargetCreation(istream &aStream)
 302   : RecordedEvent(DRAWTARGETCREATION)
 303 {
 304   ReadElement(aStream, mRefPtr);
 305   ReadElement(aStream, mBackendType);
 306   ReadElement(aStream, mSize);
 307   ReadElement(aStream, mFormat);
 308 }
 309
 310 void
 311 RecordedDrawTargetCreation::OutputSimpleEventInfo(stringstream &aStringStream) const
 312 {
 313   aStringStream << "[" << mRefPtr << "] DrawTarget Creation (Type: " << NameFromBackend(mBackendType) << ", Size: " << mSize.width << "x" << mSize.height << ")";
 314 }
 315
 316
 317 void
 318 RecordedDrawTargetDestruction::PlayEvent(Translator *aTranslator) const
 319 {
 320   aTranslator->RemoveDrawTarget(mRefPtr);
 321 }
 322
 323 void
 324 RecordedDrawTargetDestruction::RecordToStream(ostream &aStream) const
 325 {
 326   WriteElement(aStream, mRefPtr);
 327 }
 328
 329 RecordedDrawTargetDestruction::RecordedDrawTargetDestruction(istream &aStream)
 330   : RecordedEvent(DRAWTARGETDESTRUCTION)
 331 {
 332   ReadElement(aStream, mRefPtr);
 333 }
 334
 335 void
 336 RecordedDrawTargetDestruction::OutputSimpleEventInfo(stringstream &aStringStream) const
 337 {
 338   aStringStream << "[" << mRefPtr << "] DrawTarget Destruction";
 339 }
 340
 341 struct GenericPattern
 342 {
 343   GenericPattern(const PatternStorage &aStorage, Translator *aTranslator)
 344     : mPattern(NULL), mTranslator(aTranslator)
 345   {
 346     mStorage = const_cast<PatternStorage*>(&aStorage);
 347   }
 348
 349   ~GenericPattern() {
 350     if (mPattern) {
 351       mPattern->~Pattern();
 352     }
 353   }
 354
 355   operator Pattern*()
 356   {
 357     switch(mStorage->mType) {
 358     case PATTERN_COLOR:
 359       return new (mColPat) ColorPattern(reinterpret_cast<ColorPatternStorage*>(&mStorage->mStorage)->mColor);
 360     case PATTERN_SURFACE:
 361       {
 362         SurfacePatternStorage *storage = reinterpret_cast<SurfacePatternStorage*>(&mStorage->mStorage);
 363         mPattern =
 364           new (mSurfPat) SurfacePattern(mTranslator->LookupSourceSurface(storage->mSurface),
 365                                         storage->mExtend, storage->mMatrix, storage->mFilter);
 366         return mPattern;
 367       }
 368     case PATTERN_LINEAR_GRADIENT:
 369       {
 370         LinearGradientPatternStorage *storage = reinterpret_cast<LinearGradientPatternStorage*>(&mStorage->mStorage);
 371         mPattern =
 372           new (mLinGradPat) LinearGradientPattern(storage->mBegin, storage->mEnd,
 373                                                   mTranslator->LookupGradientStops(storage->mStops),
 374                                                   storage->mMatrix);
 375         return mPattern;
 376       }
 377     case PATTERN_RADIAL_GRADIENT:
 378       {
 379         RadialGradientPatternStorage *storage = reinterpret_cast<RadialGradientPatternStorage*>(&mStorage->mStorage);
 380         mPattern =
 381           new (mRadGradPat) RadialGradientPattern(storage->mCenter1, storage->mCenter2,
 382                                                   storage->mRadius1, storage->mRadius2,
 383                                                   mTranslator->LookupGradientStops(storage->mStops),
 384                                                   storage->mMatrix);
 385         return mPattern;
 386       }
 387     default:
 388       return new (mColPat) ColorPattern(Color());
 389     }
 390
 391     return mPattern;
 392   }
 393
 394   union {
 395     char mColPat[sizeof(ColorPattern)];
 396     char mLinGradPat[sizeof(LinearGradientPattern)];
 397     char mRadGradPat[sizeof(RadialGradientPattern)];
 398     char mSurfPat[sizeof(SurfacePattern)];
 399   };
 400
 401   PatternStorage *mStorage;
 402   Pattern *mPattern;
 403   Translator *mTranslator;
 404 };
 405
 406 void
 407 RecordedFillRect::PlayEvent(Translator *aTranslator) const
 408 {
 409   aTranslator->LookupDrawTarget(mDT)->FillRect(mRect, *GenericPattern(mPattern, aTranslator), mOptions);
 410 }
 411
 412 void
 413 RecordedFillRect::RecordToStream(ostream &aStream) const
 414 {
 415   RecordedDrawingEvent::RecordToStream(aStream);
 416   WriteElement(aStream, mRect);
 417   WriteElement(aStream, mOptions);
 418   RecordPatternData(aStream, mPattern);
 419 }
 420
 421 RecordedFillRect::RecordedFillRect(istream &aStream)
 422   : RecordedDrawingEvent(FILLRECT, aStream)
 423 {
 424   ReadElement(aStream, mRect);
 425   ReadElement(aStream, mOptions);
 426   ReadPatternData(aStream, mPattern);
 427 }
 428
 429 void
 430 RecordedFillRect::OutputSimpleEventInfo(stringstream &aStringStream) const
 431 {
 432   aStringStream << "[" << mDT << "] FillRect (" << mRect.x << ", " << mRect.y << " - " << mRect.width << " x " << mRect.height << ") ";
 433   OutputSimplePatternInfo(mPattern, aStringStream);
 434 }
 435
 436 void
 437 RecordedStrokeRect::PlayEvent(Translator *aTranslator) const
 438 {
 439   aTranslator->LookupDrawTarget(mDT)->StrokeRect(mRect, *GenericPattern(mPattern, aTranslator), mStrokeOptions, mOptions);
 440 }
 441
 442 void
 443 RecordedStrokeRect::RecordToStream(ostream &aStream) const
 444 {
 445   RecordedDrawingEvent::RecordToStream(aStream);
 446   WriteElement(aStream, mRect);
 447   WriteElement(aStream, mOptions);
 448   RecordPatternData(aStream, mPattern);
 449   RecordStrokeOptions(aStream, mStrokeOptions);
 450 }
 451
 452 RecordedStrokeRect::RecordedStrokeRect(istream &aStream)
 453   : RecordedDrawingEvent(STROKERECT, aStream)
 454 {
 455   ReadElement(aStream, mRect);
 456   ReadElement(aStream, mOptions);
 457   ReadPatternData(aStream, mPattern);
 458   ReadStrokeOptions(aStream, mStrokeOptions);
 459 }
 460
 461 void
 462 RecordedStrokeRect::OutputSimpleEventInfo(stringstream &aStringStream) const
 463 {
 464   aStringStream << "[" << mDT << "] StrokeRect (" << mRect.x << ", " << mRect.y << " - " << mRect.width << " x " << mRect.height
 465                 << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
 466   OutputSimplePatternInfo(mPattern, aStringStream);
 467 }
 468
 469 void
 470 RecordedStrokeLine::PlayEvent(Translator *aTranslator) const
 471 {
 472   aTranslator->LookupDrawTarget(mDT)->StrokeLine(mBegin, mEnd, *GenericPattern(mPattern, aTranslator), mStrokeOptions, mOptions);
 473 }
 474
 475 void
 476 RecordedStrokeLine::RecordToStream(ostream &aStream) const
 477 {
 478   RecordedDrawingEvent::RecordToStream(aStream);
 479   WriteElement(aStream, mBegin);
 480   WriteElement(aStream, mEnd);
 481   WriteElement(aStream, mOptions);
 482   RecordPatternData(aStream, mPattern);
 483   RecordStrokeOptions(aStream, mStrokeOptions);
 484 }
 485
 486 RecordedStrokeLine::RecordedStrokeLine(istream &aStream)
 487   : RecordedDrawingEvent(STROKELINE, aStream)
 488 {
 489   ReadElement(aStream, mBegin);
 490   ReadElement(aStream, mEnd);
 491   ReadElement(aStream, mOptions);
 492   ReadPatternData(aStream, mPattern);
 493   ReadStrokeOptions(aStream, mStrokeOptions);
 494 }
 495
 496 void
 497 RecordedStrokeLine::OutputSimpleEventInfo(stringstream &aStringStream) const
 498 {
 499   aStringStream << "[" << mDT << "] StrokeLine (" << mBegin.x << ", " << mBegin.y << " - " << mEnd.x << ", " << mEnd.y
 500                 << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
 501   OutputSimplePatternInfo(mPattern, aStringStream);
 502 }
 503
 504 void
 505 RecordedFill::PlayEvent(Translator *aTranslator) const
 506 {
 507   aTranslator->LookupDrawTarget(mDT)->Fill(aTranslator->LookupPath(mPath), *GenericPattern(mPattern, aTranslator), mOptions);
 508 }
 509
 510 RecordedFill::RecordedFill(istream &aStream)
 511   : RecordedDrawingEvent(FILL, aStream)
 512 {
 513   ReadElement(aStream, mPath);
 514   ReadElement(aStream, mOptions);
 515   ReadPatternData(aStream, mPattern);
 516 }
 517
 518 void
 519 RecordedFill::RecordToStream(ostream &aStream) const
 520 {
 521   RecordedDrawingEvent::RecordToStream(aStream);
 522   WriteElement(aStream, mPath);
 523   WriteElement(aStream, mOptions);
 524   RecordPatternData(aStream, mPattern);
 525 }
 526
 527 void
 528 RecordedFill::OutputSimpleEventInfo(stringstream &aStringStream) const
 529 {
 530   aStringStream << "[" << mDT << "] Fill (" << mPath << ") ";
 531   OutputSimplePatternInfo(mPattern, aStringStream);
 532 }
 533
 534 RecordedFillGlyphs::~RecordedFillGlyphs()
 535 {
 536   delete [] mGlyphs;
 537 }
 538
 539 void
 540 RecordedFillGlyphs::PlayEvent(Translator *aTranslator) const
 541 {
 542   GlyphBuffer buffer;
 543   buffer.mGlyphs = mGlyphs;
 544   buffer.mNumGlyphs = mNumGlyphs;
 545   aTranslator->LookupDrawTarget(mDT)->FillGlyphs(aTranslator->LookupScaledFont(mScaledFont), buffer, *GenericPattern(mPattern, aTranslator), mOptions);
 546 }
 547
 548 RecordedFillGlyphs::RecordedFillGlyphs(istream &aStream)
 549   : RecordedDrawingEvent(FILLGLYPHS, aStream)
 550 {
 551   ReadElement(aStream, mScaledFont);
 552   ReadElement(aStream, mOptions);
 553   ReadPatternData(aStream, mPattern);
 554   ReadElement(aStream, mNumGlyphs);
 555   mGlyphs = new Glyph[mNumGlyphs];
 556   aStream.read((char*)mGlyphs, sizeof(Glyph) * mNumGlyphs);
 557 }
 558
 559 void
 560 RecordedFillGlyphs::RecordToStream(ostream &aStream) const
 561 {
 562   RecordedDrawingEvent::RecordToStream(aStream);
 563   WriteElement(aStream, mScaledFont);
 564   WriteElement(aStream, mOptions);
 565   RecordPatternData(aStream, mPattern);
 566   WriteElement(aStream, mNumGlyphs);
 567   aStream.write((char*)mGlyphs, sizeof(Glyph) * mNumGlyphs);
 568 }
 569
 570 void
 571 RecordedFillGlyphs::OutputSimpleEventInfo(stringstream &aStringStream) const
 572 {
 573   aStringStream << "[" << mDT << "] FillGlyphs (" << mScaledFont << ") ";
 574   OutputSimplePatternInfo(mPattern, aStringStream);
 575 }
 576
 577 void
 578 RecordedMask::PlayEvent(Translator *aTranslator) const
 579 {
 580   aTranslator->LookupDrawTarget(mDT)->Mask(*GenericPattern(mSource, aTranslator), *GenericPattern(mMask, aTranslator), mOptions);
 581 }
 582
 583 RecordedMask::RecordedMask(istream &aStream)
 584   : RecordedDrawingEvent(MASK, aStream)
 585 {
 586   ReadElement(aStream, mOptions);
 587   ReadPatternData(aStream, mSource);
 588   ReadPatternData(aStream, mMask);
 589 }
 590
 591 void
 592 RecordedMask::RecordToStream(ostream &aStream) const
 593 {
 594   RecordedDrawingEvent::RecordToStream(aStream);
 595   WriteElement(aStream, mOptions);
 596   RecordPatternData(aStream, mSource);
 597   RecordPatternData(aStream, mMask);
 598 }
 599
 600 void
 601 RecordedMask::OutputSimpleEventInfo(stringstream &aStringStream) const
 602 {
 603   aStringStream << "[" << mDT << "] Mask (Source: ";
 604   OutputSimplePatternInfo(mSource, aStringStream);
 605   aStringStream << " Mask: ";
 606   OutputSimplePatternInfo(mMask, aStringStream);
 607 }
 608
 609 void
 610 RecordedStroke::PlayEvent(Translator *aTranslator) const
 611 {
 612   aTranslator->LookupDrawTarget(mDT)->Stroke(aTranslator->LookupPath(mPath), *GenericPattern(mPattern, aTranslator), mStrokeOptions, mOptions);
 613 }
 614
 615 void
 616 RecordedStroke::RecordToStream(ostream &aStream) const
 617 {
 618   RecordedDrawingEvent::RecordToStream(aStream);
 619   WriteElement(aStream, mPath);
 620   WriteElement(aStream, mOptions);
 621   RecordPatternData(aStream, mPattern);
 622   RecordStrokeOptions(aStream, mStrokeOptions);
 623 }
 624
 625 RecordedStroke::RecordedStroke(istream &aStream)
 626   : RecordedDrawingEvent(STROKE, aStream)
 627 {
 628   ReadElement(aStream, mPath);
 629   ReadElement(aStream, mOptions);
 630   ReadPatternData(aStream, mPattern);
 631   ReadStrokeOptions(aStream, mStrokeOptions);
 632 }
 633
 634 void
 635 RecordedStroke::OutputSimpleEventInfo(stringstream &aStringStream) const
 636 {
 637   aStringStream << "[" << mDT << "] Stroke ("<< mPath << ") LineWidth: " << mStrokeOptions.mLineWidth << "px ";
 638   OutputSimplePatternInfo(mPattern, aStringStream);
 639 }
 640
 641 void
 642 RecordedClearRect::PlayEvent(Translator *aTranslator) const
 643 {
 644   aTranslator->LookupDrawTarget(mDT)->ClearRect(mRect);
 645 }
 646
 647 void
 648 RecordedClearRect::RecordToStream(ostream &aStream) const
 649 {
 650   RecordedDrawingEvent::RecordToStream(aStream);
 651   WriteElement(aStream, mRect);
 652 }
 653
 654 RecordedClearRect::RecordedClearRect(istream &aStream)
 655   : RecordedDrawingEvent(CLEARRECT, aStream)
 656 {
 657     ReadElement(aStream, mRect);
 658 }
 659
 660 void
 661 RecordedClearRect::OutputSimpleEventInfo(stringstream &aStringStream) const
 662 {
 663   aStringStream << "[" << mDT<< "] ClearRect (" << mRect.x << ", " << mRect.y << " - " << mRect.width << " x " << mRect.height << ") ";
 664 }
 665
 666 void
 667 RecordedCopySurface::PlayEvent(Translator *aTranslator) const
 668 {
 669         aTranslator->LookupDrawTarget(mDT)->CopySurface(aTranslator->LookupSourceSurface(mSourceSurface),
 670                                                   mSourceRect, mDest);
 671 }
 672
 673 void
 674 RecordedCopySurface::RecordToStream(ostream &aStream) const
 675 {
 676   RecordedDrawingEvent::RecordToStream(aStream);
 677   WriteElement(aStream, mSourceSurface);
 678   WriteElement(aStream, mSourceRect);
 679   WriteElement(aStream, mDest);
 680 }
 681
 682 RecordedCopySurface::RecordedCopySurface(istream &aStream)
 683   : RecordedDrawingEvent(COPYSURFACE, aStream)
 684 {
 685   ReadElement(aStream, mSourceSurface);
 686   ReadElement(aStream, mSourceRect);
 687   ReadElement(aStream, mDest);
 688 }
 689
 690 void
 691 RecordedCopySurface::OutputSimpleEventInfo(stringstream &aStringStream) const
 692 {
 693   aStringStream << "[" << mDT<< "] CopySurface (" << mSourceSurface << ")";
 694 }
 695
 696 void
 697 RecordedPushClip::PlayEvent(Translator *aTranslator) const
 698 {
 699   aTranslator->LookupDrawTarget(mDT)->PushClip(aTranslator->LookupPath(mPath));
 700 }
 701
 702 void
 703 RecordedPushClip::RecordToStream(ostream &aStream) const
 704 {
 705   RecordedDrawingEvent::RecordToStream(aStream);
 706   WriteElement(aStream, mPath);
 707 }
 708
 709 RecordedPushClip::RecordedPushClip(istream &aStream)
 710   : RecordedDrawingEvent(PUSHCLIP, aStream)
 711 {
 712   ReadElement(aStream, mPath);
 713 }
 714
 715 void
 716 RecordedPushClip::OutputSimpleEventInfo(stringstream &aStringStream) const
 717 {
 718   aStringStream << "[" << mDT << "] PushClip (" << mPath << ") ";
 719 }
 720
 721 void
 722 RecordedPushClipRect::PlayEvent(Translator *aTranslator) const
 723 {
 724   aTranslator->LookupDrawTarget(mDT)->PushClipRect(mRect);
 725 }
 726
 727 void
 728 RecordedPushClipRect::RecordToStream(ostream &aStream) const
 729 {
 730   RecordedDrawingEvent::RecordToStream(aStream);
 731   WriteElement(aStream, mRect);
 732 }
 733
 734 RecordedPushClipRect::RecordedPushClipRect(istream &aStream)
 735   : RecordedDrawingEvent(PUSHCLIPRECT, aStream)
 736 {
 737   ReadElement(aStream, mRect);
 738 }
 739
 740 void
 741 RecordedPushClipRect::OutputSimpleEventInfo(stringstream &aStringStream) const
 742 {
 743   aStringStream << "[" << mDT << "] PushClipRect (" << mRect.x << ", " << mRect.y << " - " << mRect.width << " x " << mRect.height << ") ";
 744 }
 745
 746 void
 747 RecordedPopClip::PlayEvent(Translator *aTranslator) const
 748 {
 749   aTranslator->LookupDrawTarget(mDT)->PopClip();
 750 }
 751
 752 void
 753 RecordedPopClip::RecordToStream(ostream &aStream) const
 754 {
 755   RecordedDrawingEvent::RecordToStream(aStream);
 756 }
 757
 758 RecordedPopClip::RecordedPopClip(istream &aStream)
 759   : RecordedDrawingEvent(POPCLIP, aStream)
 760 {
 761 }
 762
 763 void
 764 RecordedPopClip::OutputSimpleEventInfo(stringstream &aStringStream) const
 765 {
 766   aStringStream << "[" << mDT << "] PopClip";
 767 }
 768
 769 void
 770 RecordedSetTransform::PlayEvent(Translator *aTranslator) const
 771 {
 772   aTranslator->LookupDrawTarget(mDT)->SetTransform(mTransform);
 773 }
 774
 775 void
 776 RecordedSetTransform::RecordToStream(ostream &aStream) const
 777 {
 778   RecordedDrawingEvent::RecordToStream(aStream);
 779   WriteElement(aStream, mTransform);
 780 }
 781
 782 RecordedSetTransform::RecordedSetTransform(istream &aStream)
 783   : RecordedDrawingEvent(SETTRANSFORM, aStream)
 784 {
 785   ReadElement(aStream, mTransform);
 786 }
 787
 788 void
 789 RecordedSetTransform::OutputSimpleEventInfo(stringstream &aStringStream) const
 790 {
 791   aStringStream << "[" << mDT << "] SetTransform [ " << mTransform._11 << " " << mTransform._12 << " ; " <<
 792     mTransform._21 << " " << mTransform._22 << " ; " << mTransform._31 << " " << mTransform._32 << " ]";
 793 }
 794
 795 void
 796 RecordedDrawSurface::PlayEvent(Translator *aTranslator) const
 797 {
 798   aTranslator->LookupDrawTarget(mDT)->
 799     DrawSurface(aTranslator->LookupSourceSurface(mRefSource), mDest, mSource,
 800                 mDSOptions, mOptions);
 801 }
 802
 803 void
 804 RecordedDrawSurface::RecordToStream(ostream &aStream) const
 805 {
 806   RecordedDrawingEvent::RecordToStream(aStream);
 807   WriteElement(aStream, mRefSource);
 808   WriteElement(aStream, mDest);
 809   WriteElement(aStream, mSource);
 810   WriteElement(aStream, mDSOptions);
 811   WriteElement(aStream, mOptions);
 812 }
 813
 814 RecordedDrawSurface::RecordedDrawSurface(istream &aStream)
 815   : RecordedDrawingEvent(DRAWSURFACE, aStream)
 816 {
 817   ReadElement(aStream, mRefSource);
 818   ReadElement(aStream, mDest);
 819   ReadElement(aStream, mSource);
 820   ReadElement(aStream, mDSOptions);
 821   ReadElement(aStream, mOptions);
 822 }
 823
 824 void
 825 RecordedDrawSurface::OutputSimpleEventInfo(stringstream &aStringStream) const
 826 {
 827   aStringStream << "[" << mDT << "] DrawSurface (" << mRefSource << ")";
 828 }
 829
 830 void
 831 RecordedDrawSurfaceWithShadow::PlayEvent(Translator *aTranslator) const
 832 {
 833   aTranslator->LookupDrawTarget(mDT)->
 834     DrawSurfaceWithShadow(aTranslator->LookupSourceSurface(mRefSource),
 835                           mDest, mColor, mOffset, mSigma, mOp);
 836 }
 837
 838 void
 839 RecordedDrawSurfaceWithShadow::RecordToStream(ostream &aStream) const
 840 {
 841   RecordedDrawingEvent::RecordToStream(aStream);
 842   WriteElement(aStream, mRefSource);
 843   WriteElement(aStream, mDest);
 844   WriteElement(aStream, mColor);
 845   WriteElement(aStream, mOffset);
 846   WriteElement(aStream, mSigma);
 847   WriteElement(aStream, mOp);
 848 }
 849
 850 RecordedDrawSurfaceWithShadow::RecordedDrawSurfaceWithShadow(istream &aStream)
 851   : RecordedDrawingEvent(DRAWSURFACEWITHSHADOW, aStream)
 852 {
 853   ReadElement(aStream, mRefSource);
 854   ReadElement(aStream, mDest);
 855   ReadElement(aStream, mColor);
 856   ReadElement(aStream, mOffset);
 857   ReadElement(aStream, mSigma);
 858   ReadElement(aStream, mOp);
 859 }
 860
 861 void
 862 RecordedDrawSurfaceWithShadow::OutputSimpleEventInfo(stringstream &aStringStream) const
 863 {
 864   aStringStream << "[" << mDT << "] DrawSurfaceWithShadow (" << mRefSource << ") Color: (" <<
 865     mColor.r << ", " << mColor.g << ", " << mColor.b << ", " << mColor.a << ")";
 866 }
 867
 868 RecordedPathCreation::RecordedPathCreation(PathRecording *aPath)
 869   : RecordedEvent(PATHCREATION), mRefPtr(aPath), mFillRule(aPath->mFillRule), mPathOps(aPath->mPathOps)
 870 {
 871 }
 872
 873 RecordedPathCreation::~RecordedPathCreation()
 874 {
 875 }
 876
 877 void
 878 RecordedPathCreation::PlayEvent(Translator *aTranslator) const
 879 {
 880   RefPtr<PathBuilder> builder =
 881     aTranslator->GetReferenceDrawTarget()->CreatePathBuilder(mFillRule);
 882
 883   for (size_t i = 0; i < mPathOps.size(); i++) {
 884     const PathOp &op = mPathOps[i];
 885     switch (op.mType) {
 886     case PathOp::OP_MOVETO:
 887       builder->MoveTo(op.mP1);
 888       break;
 889     case PathOp::OP_LINETO:
 890       builder->LineTo(op.mP1);
 891       break;
 892     case PathOp::OP_BEZIERTO:
 893       builder->BezierTo(op.mP1, op.mP2, op.mP3);
 894       break;
 895     case PathOp::OP_QUADRATICBEZIERTO:
 896       builder->QuadraticBezierTo(op.mP1, op.mP2);
 897       break;
 898     case PathOp::OP_CLOSE:
 899       builder->Close();
 900       break;
 901     }
 902   }
 903
 904   RefPtr<Path> path = builder->Finish();
 905   aTranslator->AddPath(mRefPtr, path);
 906 }
 907
 908 void
 909 RecordedPathCreation::RecordToStream(ostream &aStream) const
 910 {
 911   WriteElement(aStream, mRefPtr);
 912   WriteElement(aStream, uint64_t(mPathOps.size()));
 913   WriteElement(aStream, mFillRule);
 914   typedef std::vector<PathOp> pathOpVec;
 915   for (pathOpVec::const_iterator iter = mPathOps.begin(); iter != mPathOps.end(); iter++) {
 916     WriteElement(aStream, iter->mType);
 917     if (sPointCount[iter->mType] >= 1) {
 918       WriteElement(aStream, iter->mP1);
 919     }
 920     if (sPointCount[iter->mType] >= 2) {
 921       WriteElement(aStream, iter->mP2);
 922     }
 923     if (sPointCount[iter->mType] >= 3) {
 924       WriteElement(aStream, iter->mP3);
 925     }
 926   }
 927
 928 }
 929
 930 RecordedPathCreation::RecordedPathCreation(istream &aStream)
 931   : RecordedEvent(PATHCREATION)
 932 {
 933   uint64_t size;
 934
 935   ReadElement(aStream, mRefPtr);
 936   ReadElement(aStream, size);
 937   ReadElement(aStream, mFillRule);
 938
 939   for (uint64_t i = 0; i < size; i++) {
 940     PathOp newPathOp;
 941     ReadElement(aStream, newPathOp.mType);
 942     if (sPointCount[newPathOp.mType] >= 1) {
 943       ReadElement(aStream, newPathOp.mP1);
 944     }
 945     if (sPointCount[newPathOp.mType] >= 2) {
 946       ReadElement(aStream, newPathOp.mP2);
 947     }
 948     if (sPointCount[newPathOp.mType] >= 3) {
 949       ReadElement(aStream, newPathOp.mP3);
 950     }
 951
 952     mPathOps.push_back(newPathOp);
 953   }
 954
 955 }
 956
 957 void
 958 RecordedPathCreation::OutputSimpleEventInfo(stringstream &aStringStream) const
 959 {
 960   aStringStream << "[" << mRefPtr << "] Path created (OpCount: " << mPathOps.size() << ")";
 961 }
 962 void
 963 RecordedPathDestruction::PlayEvent(Translator *aTranslator) const
 964 {
 965   aTranslator->RemovePath(mRefPtr);
 966 }
 967
 968 void
 969 RecordedPathDestruction::RecordToStream(ostream &aStream) const
 970 {
 971   WriteElement(aStream, mRefPtr);
 972 }
 973
 974 RecordedPathDestruction::RecordedPathDestruction(istream &aStream)
 975   : RecordedEvent(PATHDESTRUCTION)
 976 {
 977   ReadElement(aStream, mRefPtr);
 978 }
 979
 980 void
 981 RecordedPathDestruction::OutputSimpleEventInfo(stringstream &aStringStream) const
 982 {
 983   aStringStream << "[" << mRefPtr << "] Path Destroyed";
 984 }
 985
 986 RecordedSourceSurfaceCreation::~RecordedSourceSurfaceCreation()
 987 {
 988   if (mDataOwned) {
 989     delete [] mData;
 990   }
 991 }
 992
 993 void
 994 RecordedSourceSurfaceCreation::PlayEvent(Translator *aTranslator) const
 995 {
 996   RefPtr<SourceSurface> src = aTranslator->GetReferenceDrawTarget()->
 997     CreateSourceSurfaceFromData(mData, mSize, mSize.width * BytesPerPixel(mFormat), mFormat);
 998   aTranslator->AddSourceSurface(mRefPtr, src);
 999 }
1000
1001 void
1002 RecordedSourceSurfaceCreation::RecordToStream(ostream &aStream) const
1003 {
1004   WriteElement(aStream, mRefPtr);
1005   WriteElement(aStream, mSize);
1006   WriteElement(aStream, mFormat);
1007   for (int y = 0; y < mSize.height; y++) {
1008     aStream.write((const char*)mData + y * mStride, BytesPerPixel(mFormat) * mSize.width);
1009   }
1010 }
1011
1012 RecordedSourceSurfaceCreation::RecordedSourceSurfaceCreation(istream &aStream)
1013   : RecordedEvent(SOURCESURFACECREATION), mDataOwned(true)
1014 {
1015   ReadElement(aStream, mRefPtr);
1016   ReadElement(aStream, mSize);
1017   ReadElement(aStream, mFormat);
1018   mData = (uint8_t*)new char[mSize.width * mSize.height * BytesPerPixel(mFormat)];
1019   aStream.read((char*)mData, mSize.width * mSize.height * BytesPerPixel(mFormat));
1020 }
1021
1022 void
1023 RecordedSourceSurfaceCreation::OutputSimpleEventInfo(stringstream &aStringStream) const
1024 {
1025   aStringStream << "[" << mRefPtr << "] SourceSurface created (Size: " << mSize.width << "x" << mSize.height << ")";
1026 }
1027
1028 void
1029 RecordedSourceSurfaceDestruction::PlayEvent(Translator *aTranslator) const
1030 {
1031   aTranslator->RemoveSourceSurface(mRefPtr);
1032 }
1033
1034 void
1035 RecordedSourceSurfaceDestruction::RecordToStream(ostream &aStream) const
1036 {
1037   WriteElement(aStream, mRefPtr);
1038 }
1039
1040 RecordedSourceSurfaceDestruction::RecordedSourceSurfaceDestruction(istream &aStream)
1041   : RecordedEvent(SOURCESURFACEDESTRUCTION)
1042 {
1043   ReadElement(aStream, mRefPtr);
1044 }
1045
1046 void
1047 RecordedSourceSurfaceDestruction::OutputSimpleEventInfo(stringstream &aStringStream) const
1048 {
1049   aStringStream << "[" << mRefPtr << "] SourceSurface Destroyed";
1050 }
1051
1052 RecordedGradientStopsCreation::~RecordedGradientStopsCreation()
1053 {
1054   if (mDataOwned) {
1055     delete [] mStops;
1056   }
1057 }
1058
1059 void
1060 RecordedGradientStopsCreation::PlayEvent(Translator *aTranslator) const
1061 {
1062   RefPtr<GradientStops> src = aTranslator->GetReferenceDrawTarget()->
1063     CreateGradientStops(mStops, mNumStops, mExtendMode);
1064   aTranslator->AddGradientStops(mRefPtr, src);
1065 }
1066
1067 void
1068 RecordedGradientStopsCreation::RecordToStream(ostream &aStream) const
1069 {
1070   WriteElement(aStream, mRefPtr);
1071   WriteElement(aStream, mExtendMode);
1072   WriteElement(aStream, mNumStops);
1073   aStream.write((const char*)mStops, mNumStops * sizeof(GradientStop));
1074 }
1075
1076 RecordedGradientStopsCreation::RecordedGradientStopsCreation(istream &aStream)
1077   : RecordedEvent(GRADIENTSTOPSCREATION), mDataOwned(true)
1078 {
1079   ReadElement(aStream, mRefPtr);
1080   ReadElement(aStream, mExtendMode);
1081   ReadElement(aStream, mNumStops);
1082   mStops = new GradientStop[mNumStops];
1083
1084   aStream.read((char*)mStops, mNumStops * sizeof(GradientStop));
1085 }
1086
1087 void
1088 RecordedGradientStopsCreation::OutputSimpleEventInfo(stringstream &aStringStream) const
1089 {
1090   aStringStream << "[" << mRefPtr << "] GradientStops created (Stops: " << mNumStops << ")";
1091 }
1092
1093 void
1094 RecordedGradientStopsDestruction::PlayEvent(Translator *aTranslator) const
1095 {
1096   aTranslator->RemoveGradientStops(mRefPtr);
1097 }
1098
1099 void
1100 RecordedGradientStopsDestruction::RecordToStream(ostream &aStream) const
1101 {
1102   WriteElement(aStream, mRefPtr);
1103 }
1104
1105 RecordedGradientStopsDestruction::RecordedGradientStopsDestruction(istream &aStream)
1106   : RecordedEvent(GRADIENTSTOPSDESTRUCTION)
1107 {
1108   ReadElement(aStream, mRefPtr);
1109 }
1110
1111 void
1112 RecordedGradientStopsDestruction::OutputSimpleEventInfo(stringstream &aStringStream) const
1113 {
1114   aStringStream << "[" << mRefPtr << "] GradientStops Destroyed";
1115 }
1116
1117 void
1118 RecordedSnapshot::PlayEvent(Translator *aTranslator) const
1119 {
1120   RefPtr<SourceSurface> src = aTranslator->LookupDrawTarget(mDT)->Snapshot();
1121   aTranslator->AddSourceSurface(mRefPtr, src);
1122 }
1123
1124 void
1125 RecordedSnapshot::RecordToStream(ostream &aStream) const
1126 {
1127   WriteElement(aStream, mRefPtr);
1128   WriteElement(aStream, mDT);
1129 }
1130
1131 RecordedSnapshot::RecordedSnapshot(istream &aStream)
1132   : RecordedEvent(SNAPSHOT)
1133 {
1134   ReadElement(aStream, mRefPtr);
1135   ReadElement(aStream, mDT);
1136 }
1137
1138 void
1139 RecordedSnapshot::OutputSimpleEventInfo(stringstream &aStringStream) const
1140 {
1141   aStringStream << "[" << mRefPtr << "] Snapshot Created (DT: " << mDT << ")";
1142 }
1143
1144 RecordedScaledFontCreation::~RecordedScaledFontCreation()
1145 {
1146   delete [] mData;
1147 }
1148
1149 void
1150 RecordedScaledFontCreation::PlayEvent(Translator *aTranslator) const
1151 {
1152   RefPtr<ScaledFont> scaledFont =
1153     Factory::CreateScaledFontForTrueTypeData(mData, mSize, mIndex, mGlyphSize,
1154                                              aTranslator->GetDesiredFontType());
1155   aTranslator->AddScaledFont(mRefPtr, scaledFont);
1156 }
1157
1158 void
1159 RecordedScaledFontCreation::RecordToStream(std::ostream &aStream) const
1160 {
1161   WriteElement(aStream, mRefPtr);
1162   WriteElement(aStream, mIndex);
1163   WriteElement(aStream, mGlyphSize);
1164   WriteElement(aStream, mSize);
1165   aStream.write((const char*)mData, mSize);
1166 }
1167
1168 void
1169 RecordedScaledFontCreation::OutputSimpleEventInfo(stringstream &aStringStream) const
1170 {
1171   aStringStream << "[" << mRefPtr << "] ScaledFont Created";
1172 }
1173
1174 void
1175 RecordedScaledFontCreation::SetFontData(const uint8_t *aData, uint32_t aSize, uint32_t aIndex, Float aGlyphSize)
1176 {
1177   mData = new uint8_t[aSize];
1178   memcpy(mData, aData, aSize);
1179   mSize = aSize;
1180   mIndex = aIndex;
1181   mGlyphSize = aGlyphSize;
1182 }
1183
1184 RecordedScaledFontCreation::RecordedScaledFontCreation(istream &aStream)
1185   : RecordedEvent(SCALEDFONTCREATION)
1186 {
1187   ReadElement(aStream, mRefPtr);
1188   ReadElement(aStream, mIndex);
1189   ReadElement(aStream, mGlyphSize);
1190   ReadElement(aStream, mSize);
1191   mData = new uint8_t[mSize];
1192   aStream.read((char*)mData, mSize);
1193 }
1194
1195 void
1196 RecordedScaledFontDestruction::PlayEvent(Translator *aTranslator) const
1197 {
1198   aTranslator->RemoveScaledFont(mRefPtr);
1199 }
1200
1201 void
1202 RecordedScaledFontDestruction::RecordToStream(ostream &aStream) const
1203 {
1204   WriteElement(aStream, mRefPtr);
1205 }
1206
1207 RecordedScaledFontDestruction::RecordedScaledFontDestruction(istream &aStream)
1208   : RecordedEvent(SCALEDFONTDESTRUCTION)
1209 {
1210   ReadElement(aStream, mRefPtr);
1211 }
1212
1213 void
1214 RecordedScaledFontDestruction::OutputSimpleEventInfo(stringstream &aStringStream) const
1215 {
1216   aStringStream << "[" << mRefPtr << "] ScaledFont Destroyed";
1217 }
1218
1219 }
1220 }