Move memoization of multisample specs id to GrRenderTarget

src/gpu/GrGpu.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 "GrGpu.h"
 
@@ skipping 424 matching lines @@
         if (GrRenderTarget* target = surface->asRenderTarget()) {
             target->flagAsNeedingResolve(bounds);
         }
         GrTexture* texture = surface->asTexture();
         if (texture && 1 == mipLevels) {
             texture->texturePriv().dirtyMipMaps(true);
         }
     }
 }
 
-const GrGpu::MultisampleSpecs& GrGpu::getMultisampleSpecs(GrRenderTarget* rt,
-                                                          const GrStencilSettings& stencil) {
+const GrGpu::MultisampleSpecs& GrGpu::queryMultisampleSpecs(GrRenderTarget* rt,
+                                                            const GrStencilSettings& stencil) {
     SkASSERT(rt->desc().fSampleCnt > 1);
 
-#ifndef SK_DEBUG
-    // In debug mode we query the multisample info every time to verify the caching is correct.
-    if (uint8_t id = rt->renderTargetPriv().accessMultisampleSpecsID()) {
-        SkASSERT(id > 0 && id < fMultisampleSpecs.count());
-        return fMultisampleSpecs[id];
-    }
-#endif
-
     int effectiveSampleCnt;
     SkSTArray<16, SkPoint, true> pattern;
-    this->onGetMultisampleSpecs(rt, stencil, &effectiveSampleCnt, &pattern);
+    this->onQueryMultisampleSpecs(rt, stencil, &effectiveSampleCnt, &pattern);
     SkASSERT(effectiveSampleCnt >= rt->desc().fSampleCnt);
 
     uint8_t id;
     if (this->caps()->sampleLocationsSupport()) {
         SkASSERT(pattern.count() == effectiveSampleCnt);
         const auto& insertResult = fMultisampleSpecsIdMap.insert(
             MultisampleSpecsIdMap::value_type(pattern, SkTMin(fMultisampleSpecs.count(), 255)));
         id = insertResult.first->second;
         if (insertResult.second) {
             // This means the insert did not find the pattern in the map already, and therefore an
             // actual insertion took place. (We don't expect to see many unique sample patterns.)
             const SkPoint* sampleLocations = insertResult.first->first.begin();
             SkASSERT(id == fMultisampleSpecs.count());
             fMultisampleSpecs.emplace_back(id, effectiveSampleCnt, sampleLocations);
         }
     } else {
         id = effectiveSampleCnt;
         for (int i = fMultisampleSpecs.count(); i <= id; ++i) {
             fMultisampleSpecs.emplace_back(i, i, nullptr);
         }
     }
     SkASSERT(id > 0);
-    SkASSERT(!rt->renderTargetPriv().accessMultisampleSpecsID() ||
-             rt->renderTargetPriv().accessMultisampleSpecsID() == id);
 
-    rt->renderTargetPriv().accessMultisampleSpecsID() = id;
     return fMultisampleSpecs[id];
 }
 
 bool GrGpu::SamplePatternComparator::operator()(const SamplePattern& a,
                                                 const SamplePattern& b) const {
     if (a.count() != b.count()) {
         return a.count() < b.count();
     }
     for (int i = 0; i < a.count(); ++i) {
         // This doesn't have geometric meaning. We just need to define an ordering for std::map.
         if (a[i].x() != b[i].x()) {
             return a[i].x() < b[i].x();
         }
         if (a[i].y() != b[i].y()) {
             return a[i].y() < b[i].y();
         }
     }
     return false; // Equal.
 }