Remove GrGpuTraceMarker hooks until we rethink the design

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
 #include "GrClip.h"
 #include "GrClipMaskManager.h"
 #include "GrContext.h"
 #include "GrPathProcessor.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
 #include "GrPipelineBuilder.h"
 #include "GrPipeline.h"
-#include "GrTraceMarker.h"
 #include "GrVertexBuffer.h"
 #include "GrXferProcessor.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
@@ skipping 127 matching lines @@
      */
     void clear(const SkIRect* rect,
                GrColor color,
                bool canIgnoreRect,
                GrRenderTarget* renderTarget);
 
     /** Discards the contents render target. */
     void discard(GrRenderTarget*);
 
     /**
-     * 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();
-
-    /**
      * Copies a pixel rectangle from one surface to another. This call may finalize
      * reserved vertex/index data (as though a draw call was made). The src pixels
      * copied are specified by srcRect. They are copied to a rect of the same
      * size in dst with top left at dstPoint. If the src rect is clipped by the
      * src bounds then  pixel values in the dst rect corresponding to area clipped
      * by the src rect are not overwritten. This method is not guaranteed to succeed
      * depending on the type of surface, configs, etc, and the backend-specific
      * limitations.
      */
     void copySurface(GrSurface* dst,
@@ skipping 22 matching lines @@
         const GrPipeline::CreateArgs& pipelineCreateArgs() const {
             SkASSERT(this->valid());
             return fArgs;
         }
 
     private:
         GrPipeline::CreateArgs      fArgs;
     };
 
 protected:
-
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
 
-    const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
-
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrXferProcessor::DstTexture*,
                                  const SkRect* drawBounds);
 
     virtual void onDrawBatch(GrBatch*) = 0;
@@ skipping 21 matching lines @@
     virtual GrClipMaskManager* clipMaskManager() = 0;
     virtual bool setupClip(const GrPipelineBuilder&,
                            GrPipelineBuilder::AutoRestoreFragmentProcessorState*,
                            GrPipelineBuilder::AutoRestoreStencil*,
                            GrScissorState*,
                            const SkRect* devBounds) = 0;
 
     GrGpu*                  fGpu;
     const GrCaps*           fCaps;
     GrResourceProvider*     fResourceProvider;
-    // To keep track that we always have at least as many debug marker adds as removes
-    int                     fGpuTraceMarkerCount;
-    GrTraceMarkerSet        fActiveTraceMarkers;
-    GrTraceMarkerSet        fStoredTraceMarkers;
     bool                    fFlushing;
 
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * This class is JUST for clip mask manager.  Everyone else should just use draw target above.
  */
 class GrClipTarget : public GrDrawTarget {
 public:
@@ skipping 29 matching lines @@
     bool setupClip(const GrPipelineBuilder&,
                    GrPipelineBuilder::AutoRestoreFragmentProcessorState*,
                    GrPipelineBuilder::AutoRestoreStencil*,
                    GrScissorState* scissorState,
                    const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif