Make GrDrawTarget::Caps ref counted and GrGLCaps derive from it.

src/gpu/gl/GrGLContext.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 "GrGLContext.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 GrGLContextInfo& GrGLContextInfo::operator= (const GrGLContextInfo& ctxInfo) {
     fBindingInUse = ctxInfo.fBindingInUse;
     fGLVersion = ctxInfo.fGLVersion;
     fGLSLGeneration = ctxInfo.fGLSLGeneration;
     fVendor = ctxInfo.fVendor;
     fExtensions = ctxInfo.fExtensions;

[robertphillips, 2013/03/25 15:34:09]

Shouldn't there be a ref here?

[bsalomon, 2013/03/25 15:37:27]

It's object assignment not pointer assignment. Since the object in
GrGLContextInfo is writable (and there is a writable pointer getter) it seemed
safer to make a copy. The GrGLContextInfo cons always calls new to create a new
GrGLCaps.

[robertphillips, 2013/03/25 22:41:28]

Okay - missed that when reading through. Does that mean that the caps object's
ref-counted-ness is never really used?

-    fGLCaps = ctxInfo.fGLCaps;
+    *fGLCaps = *ctxInfo.fGLCaps.get();
     return *this;
 }
 
 bool GrGLContextInfo::initialize(const GrGLInterface* interface) {
     this->reset();
     // We haven't validated the GrGLInterface yet, so check for GetString
     // function pointer
     if (interface->fGetString) {
         const GrGLubyte* verUByte;
         GR_GL_CALL_RET(interface, verUByte, GetString(GR_GL_VERSION));
         const char* ver = reinterpret_cast<const char*>(verUByte);
         GrGLBinding binding = GrGLGetBindingInUseFromString(ver);
 
         if (0 != binding && interface->validate(binding) && fExtensions.init(binding, interface)) {
             fBindingInUse = binding;
 
             fGLVersion = GrGLGetVersionFromString(ver);
 
             fGLSLGeneration = GrGetGLSLGeneration(fBindingInUse, interface);
 
             fVendor = GrGLGetVendor(interface);
-            fGLCaps.init(*this, interface);
+            fGLCaps->init(*this, interface);
             return true;
         }
     }
     return false;
 }
 
 bool GrGLContextInfo::isInitialized() const {
     return kNone_GrGLBinding != fBindingInUse;
 }
 
 void GrGLContextInfo::reset() {
     fBindingInUse = kNone_GrGLBinding;
     fGLVersion = GR_GL_VER(0, 0);
     fGLSLGeneration = static_cast<GrGLSLGeneration>(0);
     fVendor = kOther_GrGLVendor;
     fExtensions.reset();
-    fGLCaps.reset();
+    fGLCaps->reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrGLContext::GrGLContext(const GrGLInterface* interface) {
     fInterface = NULL;
     this->initialize(interface);
 }
 
 GrGLContext::GrGLContext(const GrGLContext& ctx) {
     fInterface = NULL;
@@ skipping 12 matching lines @@
 }
 
 bool GrGLContext::initialize(const GrGLInterface* interface) {
     if (fInfo.initialize(interface)) {
         fInterface = interface;
         interface->ref();
         return true;
     }
     return false;
 }