OptState owns program descriptor

src/gpu/gl/GrGLProgramDesc.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+#include "GrGLProgramDesc.h"
 
-#include "gl/builders/GrGLFragmentShaderBuilder.h"
-#include "GrGLProgramDesc.h"
+#include "GrGLProcessor.h"
 #include "GrBackendProcessorFactory.h"
 #include "GrProcessor.h"
 #include "GrGpuGL.h"
 #include "GrOptDrawState.h"
-
 #include "SkChecksum.h"
+#include "gl/builders/GrGLFragmentShaderBuilder.h"
 
 /**
  * The key for an individual coord transform is made up of a matrix type and a bit that
  * indicates the source of the input coords.
  */
 enum {
     kMatrixTypeKeyBits   = 1,
     kMatrixTypeKeyMask   = (1 << kMatrixTypeKeyBits) - 1,
     kPositionCoords_Flag = (1 << kMatrixTypeKeyBits),
     kTransformKeyBits    = kMatrixTypeKeyBits + 1,
@@ skipping 146 matching lines @@
                             b, keySize);
     }
 };
 
 
 template <class ProcessorKeyBuilder>
 bool
 GrGLProgramDesc::BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
                                          const GrGLCaps& caps,
                                          bool requiresLocalCoordAttrib,
-                                         GrGLProgramDesc* desc,
+                                         GrProgramDesc* desc,
                                          int* offsetAndSizeIndex) {
     GrProcessorKeyBuilder b(&desc->fKey);
     uint16_t processorKeySize;
     uint32_t processorOffset = desc->fKey.count();
     if (processorOffset > SK_MaxU16 ||
             !ProcessorKeyBuilder::GetProcessorKey(stage, caps, requiresLocalCoordAttrib, &b,
                                                   &processorKeySize)){
         desc->fKey.reset();
         return false;
     }
@@ skipping 48 matching lines @@
                                                                   requiresLocalCoordAttrib,
                                                                   desc,
                                                                   &offsetAndSizeIndex)) {
             return false;
         }
     }
 
     // --------DO NOT MOVE HEADER ABOVE THIS LINE--------------------------------------------------
     // Because header is a pointer into the dynamic array, we can't push any new data into the key
     // below here.
-    KeyHeader* header = desc->header();
+    GLKeyHeader* header = desc->atOffset<GLKeyHeader, kHeaderOffset>();
 
     // make sure any padding in the header is zeroed.
     memset(header, 0, kHeaderSize);
 
     header->fHasGeometryProcessor = optState.hasGeometryProcessor();
 
     header->fEmitsPointSize = GrGpu::kDrawPoints_DrawType == drawType;
 
     if (gpu->caps()->pathRenderingSupport() &&
         GrGpu::IsPathRenderingDrawType(drawType) &&
@@ skipping 86 matching lines @@
 void GrGLProgramDesc::finalize() {
     int keyLength = fKey.count();
     SkASSERT(0 == (keyLength % 4));
     *this->atOffset<uint32_t, kLengthOffset>() = SkToU32(keyLength);
 
     uint32_t* checksum = this->atOffset<uint32_t, kChecksumOffset>();
     *checksum = 0;
     *checksum = SkChecksum::Compute(reinterpret_cast<uint32_t*>(fKey.begin()), keyLength);
 }
 
-GrGLProgramDesc& GrGLProgramDesc::operator= (const GrGLProgramDesc& other) {
-    size_t keyLength = other.keyLength();
-    fKey.reset(keyLength);
-    memcpy(fKey.begin(), other.fKey.begin(), keyLength);
-    return *this;
-}