SkTaskGroup::batch(fn, args, N)

src/core/SkMultiPictureDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #if SK_SUPPORT_GPU
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
@@ skipping 40 matching lines @@
         fGPUDrawData.setReserve(reserve);
         fThreadSafeDrawData.setReserve(reserve);
     }
 }
 
 void SkMultiPictureDraw::reset() {
     DrawData::Reset(fGPUDrawData);
     DrawData::Reset(fThreadSafeDrawData);
 }
 
-void SkMultiPictureDraw::add(SkCanvas* canvas, 
+void SkMultiPictureDraw::add(SkCanvas* canvas,
                              const SkPicture* picture,
-                             const SkMatrix* matrix, 
+                             const SkMatrix* matrix,
                              const SkPaint* paint) {
     if (NULL == canvas || NULL == picture) {
         SkDEBUGFAIL("parameters to SkMultiPictureDraw::add should be non-NULL");
         return;
     }
 
     SkTDArray<DrawData>& array = canvas->getGrContext() ? fGPUDrawData : fThreadSafeDrawData;
     array.append()->init(canvas, picture, matrix, paint);
 }
 
 #undef SK_IGNORE_GPU_LAYER_HOISTING
 #define SK_IGNORE_GPU_LAYER_HOISTING 1
 
 class AutoMPDReset : SkNoncopyable {
     SkMultiPictureDraw* fMPD;
 public:
     AutoMPDReset(SkMultiPictureDraw* mpd) : fMPD(mpd) {}
     ~AutoMPDReset() { fMPD->reset(); }
 };
 
 void SkMultiPictureDraw::draw() {
     AutoMPDReset mpdreset(this);
     // we place the taskgroup after the MPDReset, to ensure that we don't delete the DrawData
     // objects until after we're finished the tasks (which have pointers to the data).
 
     SkTaskGroup group;
     for (int i = 0; i < fThreadSafeDrawData.count(); ++i) {
-        group.add(DrawData::Run, &fThreadSafeDrawData[i]);
+        group.add(DrawData::Draw, &fThreadSafeDrawData[i]);
     }
     // we deliberately don't call wait() here, since the destructor will do that, this allows us
     // to continue processing gpu-data without having to wait on the cpu tasks.
 
     const int count = fGPUDrawData.count();
     if (0 == count) {
         return;
     }
 
 #ifndef SK_IGNORE_GPU_LAYER_HOISTING
@@ skipping 18 matching lines @@
             SkRect clipBounds;
             if (!data.fCanvas->getClipBounds(&clipBounds)) {
                 continue;
             }
 
             // TODO: sorting the cacheable layers from smallest to largest
             // would improve the packing and reduce the number of swaps
             // TODO: another optimization would be to make a first pass to
             // lock any required layer that is already in the atlas
             GrLayerHoister::FindLayersToAtlas(context, data.fPicture,
-                                              clipBounds, 
+                                              clipBounds,
                                               &atlasedNeedRendering, &atlasedRecycled);
         }
     }
 
     GrLayerHoister::DrawLayersToAtlas(context, atlasedNeedRendering);
 
     SkTDArray<GrHoistedLayer> needRendering, recycled;
 #endif
 
     for (int i = 0; i < count; ++i) {
@@ skipping 37 matching lines @@
             canvas->drawPicture(picture, &data.fMatrix, data.fPaint);
         }
     }
 
 #ifndef SK_IGNORE_GPU_LAYER_HOISTING
     GrLayerHoister::UnlockLayers(context, atlasedNeedRendering);
     GrLayerHoister::UnlockLayers(context, atlasedRecycled);
 #endif
 }