Remove GrGpuTraceMarker hooks until we rethink the design

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrPipelineBuilder.h"
 #include "GrProgramDesc.h"
 #include "GrStencil.h"
-#include "GrTraceMarker.h"
 #include "GrXferProcessor.h"
 #include "SkPath.h"
 
 class GrBatchTracker;
 class GrContext;
 class GrGLContext;
 class GrIndexBuffer;
 class GrNonInstancedVertices;
 class GrPath;
 class GrPathRange;
@@ skipping 331 matching lines @@
         void incRenderTargetBinds() {}
         void incShaderCompilations() {}
         void incTextureCreates() {}
         void incTextureUploads() {}
         void incStencilAttachmentCreates() {}
 #endif
     };
 
     Stats* stats() { return &fStats; }
 
-    /**
-     * Called at start and end of gpu trace marking
-     * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
-     * and end of a code block respectively
-     */
-    void addGpuTraceMarker(const GrGpuTraceMarker* marker);
-    void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
-
-    /**
-     * Takes the current active set of markers and stores them for later use. Any current marker
-     * in the active set is removed from the active set and the targets remove function is called.
-     * These functions do not work as a stack so you cannot call save a second time before calling
-     * restore. Also, it is assumed that when restore is called the current active set of markers
-     * is empty. When the stored markers are added back into the active set, the targets add marker
-     * is called.
-     */
-    void saveActiveTraceMarkers();
-    void restoreActiveTraceMarkers();
-
     // creation and deletion of raw texture for testing
     // only to be used in GPU-specific tests
     virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                             GrPixelConfig config) const = 0;
     virtual bool isTestingOnlyBackendTexture(GrBackendObject id) const = 0;
     virtual void deleteTestingOnlyBackendTexture(GrBackendObject id) const = 0;
 
     // Given a rt, find or create a stencil buffer and attach it
     bool attachStencilAttachmentToRenderTarget(GrRenderTarget* target);
 
@@ skipping 15 matching lines @@
     static void ElevateDrawPreference(GrGpu::DrawPreference* preference,
                                       GrGpu::DrawPreference elevation) {
         GR_STATIC_ASSERT(GrGpu::kCallerPrefersDraw_DrawPreference > GrGpu::kNoDraw_DrawPreference);
         GR_STATIC_ASSERT(GrGpu::kGpuPrefersDraw_DrawPreference >
                          GrGpu::kCallerPrefersDraw_DrawPreference);
         GR_STATIC_ASSERT(GrGpu::kRequireDraw_DrawPreference >
                          GrGpu::kGpuPrefersDraw_DrawPreference);
         *preference = SkTMax(*preference, elevation);
     }
 
-    const GrTraceMarkerSet& getActiveTraceMarkers() const { return fActiveTraceMarkers; }
-
     Stats                                   fStats;
     SkAutoTDelete<GrPathRendering>          fPathRendering;
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrCaps>    fCaps;
 
 private:
     // called when the 3D context state is unknown. Subclass should emit any
     // assumed 3D context state and dirty any state cache.
     virtual void onResetContext(uint32_t resetBits) = 0;
 
@@ skipping 60 matching lines @@
     // Should attach the SB to the RT. Returns false if compatible sb could
     // not be created.
     virtual bool createStencilAttachmentForRenderTarget(GrRenderTarget*, int width, int height) = 0;
 
     // attaches an existing SB to an existing RT.
     virtual bool attachStencilAttachmentToRenderTarget(GrStencilAttachment*, GrRenderTarget*) = 0;
 
     // clears target's entire stencil buffer to 0
     virtual void clearStencil(GrRenderTarget* target) = 0;
 
-    virtual void didAddGpuTraceMarker() = 0;
-    virtual void didRemoveGpuTraceMarker() = 0;
-
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
         ++fResetTimestamp;
     }
 
     void handleDirtyContext() {
         if (fResetBits) {
             this->resetContext();
         }
     }
 
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
-    // To keep track that we always have at least as many debug marker adds as removes
-    int                                                                 fGpuTraceMarkerCount;
-    GrTraceMarkerSet                                                    fActiveTraceMarkers;
-    GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     friend class GrPathRendering;
     typedef SkRefCnt INHERITED;
 };
 
 #endif