Devirtualize read/write pixels on surface.

src/gpu/GrAtlas.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrContext.h"
@@ skipping 74 matching lines @@
             dataPtr += fBytesPerPixel*plotWidth;
             imagePtr += fBytesPerPixel*width;
         }
 
         fDirtyRect.join(loc->fX, loc->fY, loc->fX + width, loc->fY + height);
         adjust_for_offset(loc, fOffset);
         fDirty = true;
     // otherwise, just upload the image directly
     } else if (image) {
         adjust_for_offset(loc, fOffset);
-        GrContext* context = fTexture->getContext();
         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrPlot::uploadToTexture");
-        context->writeTexturePixels(fTexture,
-                                    loc->fX, loc->fY, width, height,
-                                    fTexture->config(), image, 0,
-                                    GrContext::kDontFlush_PixelOpsFlag);
+        fTexture->writePixels(loc->fX, loc->fY, width, height, fTexture->config(), image, 0,
+                              GrContext::kDontFlush_PixelOpsFlag);
     } else {
         adjust_for_offset(loc, fOffset);
     }
 
 #if FONT_CACHE_STATS
     ++g_UploadCount;
 #endif
 
     return true;
 }
 
 void GrPlot::uploadToTexture() {
     static const float kNearlyFullTolerance = 0.85f;
 
     // should only do this if batching is enabled
     SkASSERT(fBatchUploads);
 
     if (fDirty) {
         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrPlot::uploadToTexture");
         SkASSERT(fTexture);
-        GrContext* context = fTexture->getContext();
         // We pass the flag that does not force a flush. We assume our caller is
         // smart and hasn't referenced the part of the texture we're about to update
         // since the last flush.
         size_t rowBytes = fBytesPerPixel*fRects->width();
         const unsigned char* dataPtr = fPlotData;
         dataPtr += rowBytes*fDirtyRect.fTop;
         dataPtr += fBytesPerPixel*fDirtyRect.fLeft;
-        context->writeTexturePixels(fTexture,
-                                    fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop,
-                                    fDirtyRect.width(), fDirtyRect.height(),
-                                    fTexture->config(), dataPtr,
-                                    rowBytes,
-                                    GrContext::kDontFlush_PixelOpsFlag);
+        fTexture->writePixels(fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop,
+                              fDirtyRect.width(), fDirtyRect.height(), fTexture->config(), dataPtr,
+                              rowBytes, GrContext::kDontFlush_PixelOpsFlag);
         fDirtyRect.setEmpty();
         fDirty = false;
         // If the Plot is nearly full, anything else we add will probably be small and one
         // at a time, so free up the memory and after this upload any new images directly.
         if (fRects->percentFull() > kNearlyFullTolerance) {
             SkDELETE_ARRAY(fPlotData);
             fPlotData = NULL;
         }
     }
 }
@@ skipping 140 matching lines @@
     if (fBatchUploads) {
         GrPlotList::Iter plotIter;
         plotIter.init(fPlotList, GrPlotList::Iter::kHead_IterStart);
         GrPlot* plot;
         while ((plot = plotIter.get())) {
             plot->uploadToTexture();
             plotIter.next();
         }
     }
 }