Make GrGLContextInfo have private ptr to GrGLInterface

src/gpu/gl/GrGLContext.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLContext_DEFINED
 #define GrGLContext_DEFINED
@@ skipping 13 matching lines @@
 class GrGLContextInfo {
 public:
     /**
      * Default constructor
      */
     GrGLContextInfo() {
         fGLCaps.reset(SkNEW(GrGLCaps));
         this->reset();
     }
 
-    /**
-     * Copies a GrGLContextInfo
-     */
-    GrGLContextInfo& operator= (const GrGLContextInfo& ctxInfo);
+    GrGLContextInfo(const GrGLContextInfo& that) {
+        fGLCaps.reset(SkNEW(GrGLCaps));
+        *this = that;
+    }
+
+    GrGLContextInfo& operator= (const GrGLContextInfo&);
 
     /**
      * Initializes a GrGLContextInfo from a GrGLInterface and the currently
      * bound OpenGL context accessible by the GrGLInterface.
      */
     bool initialize(const GrGLInterface* interface);
     bool isInitialized() const;
 
-    GrGLStandard standard() const { return fStandard; }
+    GrGLStandard standard() const { return fInterface->fStandard; }
     GrGLVersion version() const { return fGLVersion; }
     GrGLSLGeneration glslGeneration() const { return fGLSLGeneration; }
     GrGLVendor vendor() const { return fVendor; }
     GrGLRenderer renderer() const { return fRenderer; }
     /** Is this a mesa-based driver. Does not mean it is the osmesa software rasterizer. */
     bool isMesa() const { return fIsMesa; }
     /** Are we running inside Chromium (using the command buffer)? We make some different tradeoffs
         about what errors to check for because queries are synchronous. We should probably expose
         this as an option for clients other than Chromium. */
     bool isChromium() const { return fIsChromium; }
     const GrGLCaps* caps() const { return fGLCaps.get(); }
     GrGLCaps* caps() { return fGLCaps; }
     const GrGLExtensions& extensions() const { return fExtensions; }
 
     /**
-     * Shortcut for extensions().has(ext);
+     * Shortcut for extensions().has(ext)
      */
     bool hasExtension(const char* ext) const {
         if (!this->isInitialized()) {
             return false;
         }
         return fExtensions.has(ext);
     }
 
     /**
      * Reset the information
      */
     void reset();
 
-private:
-
-    GrGLStandard            fStandard;
-    GrGLVersion             fGLVersion;
-    GrGLSLGeneration        fGLSLGeneration;
-    GrGLVendor              fVendor;
-    GrGLRenderer            fRenderer;
-    GrGLExtensions          fExtensions;
-    bool                    fIsMesa;
-    bool                    fIsChromium;
-    SkAutoTUnref<GrGLCaps>  fGLCaps;
+protected:
+    SkAutoTUnref<const GrGLInterface>   fInterface;
+    GrGLVersion                         fGLVersion;
+    GrGLSLGeneration                    fGLSLGeneration;
+    GrGLVendor                          fVendor;
+    GrGLRenderer                        fRenderer;
+    GrGLExtensions                      fExtensions;
+    bool                                fIsMesa;
+    bool                                fIsChromium;
+    SkAutoTUnref<GrGLCaps>              fGLCaps;
 };
 
 /**
- * Encapsulates the GrGLInterface used to make GL calls plus information
- * about the context (via GrGLContextInfo).
+ * Extension of GrGLContextInfo that also provides access to GrGLInterface.
  */
-class GrGLContext {
+class GrGLContext : public GrGLContextInfo {
 public:
     /**
-     * Default constructor
-     */
-    GrGLContext() { this->reset(); }
-
-    /**
      * Creates a GrGLContext from a GrGLInterface and the currently
      * bound OpenGL context accessible by the GrGLInterface.
      */
-    explicit GrGLContext(const GrGLInterface* interface);
+    explicit GrGLContext(const GrGLInterface* interface) {
+        this->initialize(interface);
+    }
 
-    /**
-     * Copies a GrGLContext
-     */
-    GrGLContext(const GrGLContext& ctx);
+    GrGLContext(const GrGLContext& that) : INHERITED(that) {}
 
-    ~GrGLContext() { SkSafeUnref(fInterface); }
+    GrGLContext& operator= (const GrGLContext& that) {
+        this->INHERITED::operator=(that);
+        return *this;
+    }
 
-    /**
-     * Copies a GrGLContext
-     */
-    GrGLContext& operator= (const GrGLContext& ctx);
-
-    /**
-     * Initializes a GrGLContext from a GrGLInterface and the currently
-     * bound OpenGL context accessible by the GrGLInterface.
-     */
-    bool initialize(const GrGLInterface* interface);
-    bool isInitialized() const { return fInfo.isInitialized(); }
-
-    const GrGLInterface* interface() const { return fInterface; }
-    const GrGLContextInfo& info() const { return fInfo; }
-    GrGLContextInfo& info() { return fInfo; }
+    const GrGLInterface* interface() const { return fInterface.get(); }
 
 private:
-    void reset();
-
-    const GrGLInterface* fInterface;
-    GrGLContextInfo      fInfo;
+    typedef GrGLContextInfo INHERITED;
 };
 
 #endif