Make "priv" classes for GrTexure and GrSurface.

src/gpu/GrSurface.cpp

Index: src/gpu/GrSurface.cpp
diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp
index d15cbdf6e26ccc7fd3b3745cb9ced18747132395..9816c95c5a4f92b4d15fb6e14f79046cedc19cee 100644
--- a/src/gpu/GrSurface.cpp
+++ b/src/gpu/GrSurface.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "GrSurface.h"
+#include "GrSurfacePriv.h"
 
 #include "SkBitmap.h"
 #include "SkGr.h"
@@ -26,8 +27,8 @@ bool GrSurface::savePixels(const char* filename) {
         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;
@@ -80,3 +81,14 @@ bool GrSurface::hasPendingIO() const {
     }
     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();
+    }
+}