Make "priv" classes for GrTexure and GrSurface.

src/gpu/GrSurface.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSurface.h"
+#include "GrSurfacePriv.h"
 
 #include "SkBitmap.h"
 #include "SkGr.h"
 #include "SkImageEncoder.h"
 #include <stdio.h>
 
 SkImageInfo GrSurface::info() const {
     SkColorType colorType;
     if (!GrPixelConfig2ColorType(this->config(), &colorType)) {
         sk_throw();
     }
     return SkImageInfo::Make(this->width(), this->height(), colorType, kPremul_SkAlphaType);
 }
 
 bool GrSurface::savePixels(const char* filename) {
     SkBitmap bm;
     if (!bm.tryAllocPixels(SkImageInfo::MakeN32Premul(this->width(), this->height()))) {
         return false;
     }
 
-    bool result = readPixels(0, 0, this->width(), this->height(), kSkia8888_GrPixelConfig,
-                             bm.getPixels());
+    bool result = this->readPixels(0, 0, this->width(), this->height(), kSkia8888_GrPixelConfig,
+                                   bm.getPixels());
     if (!result) {
         SkDebugf("------ failed to read pixels for %s\n", filename);
         return false;
     }
 
     // remove any previous version of this file
     remove(filename);
 
     if (!SkImageEncoder::EncodeFile(filename, bm, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("------ failed to encode %s\n", filename);
@@ skipping 32 matching lines @@
     const GrTexture* thisTex = this->asTexture();
     if (thisTex && thisTex->internalHasPendingIO()) {
         return true;
     }
     const GrRenderTarget* thisRT = this->asRenderTarget();
     if (thisRT && thisRT->internalHasPendingIO()) {
         return true;
     }
     return false;
 }
+

[robertphillips, 2014/09/29 13:34:27]

It looks like GrSurfacePriv is careful to leave all the implementation in
GrSurface and just expose the methods. GrTexturePriv, on the other hand, appears
to shoulder some of the implementation burden. Should we standardize on one
approach or the other?

[joshua.litt, 2014/09/29 13:58:08]

I think my preference is to move implementations of private methods to the *Priv
classes because it prevents these functions from cluttering up the public
interface, even if they are private.  It seems more pimpl to me.  Its also one
less level of indirection for these methods.

[bsalomon, 2014/09/29 18:42:10]

I don't feel strongly either way. The passthroughs are all inlined away. I do
like not having the clutter in the public .h so I guess I also lean towards impl
in the priv function.

However, for member functions that aren't trivially inlined I worry whether
compilers will wind up actually constructing the priv object if the method
called on it isn't inline.

I think the split might be: passthrough for complex methods, impl in priv for
inlines. Added a comment to that effect.

+bool GrSurface::isSameAs(const GrSurface* other) const {
+    const GrRenderTarget* thisRT = this->asRenderTarget();
+    if (thisRT) {
+        return thisRT == other->asRenderTarget();
+    } else {
+        const GrTexture* thisTex = this->asTexture();
+        SkASSERT(thisTex); // We must be one or the other
+        return thisTex == other->asTexture();
+    }
+}