Move memory observer off OutputSurface/CompositorFrameSink

cc/output/output_surface.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_OUTPUT_OUTPUT_SURFACE_H_
 #define CC_OUTPUT_OUTPUT_SURFACE_H_
 
 #include <deque>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
-#include "base/trace_event/memory_dump_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/software_output_device.h"
 #include "cc/output/vulkan_context_provider.h"
 #include "cc/resources/returned_resource.h"
 #include "gpu/command_buffer/common/texture_in_use_response.h"
 #include "ui/gfx/color_space.h"
 
 namespace ui {
@@ skipping 13 matching lines @@
 class OutputSurfaceClient;
 class OutputSurfaceFrame;
 
 // Represents the output surface for a compositor. The compositor owns
 // and manages its destruction. Its lifetime is:
 //   1. Created on the main thread by the LayerTreeHost through its client.
 //   2. Passed to the compositor thread and bound to a client via BindToClient.
 //      From here on, it will only be used on the compositor thread.
 //   3. If the 3D context is lost, then the compositor will delete the output
 //      surface (on the compositor thread) and go back to step 1.
-class CC_EXPORT OutputSurface : public base::trace_event::MemoryDumpProvider {
+class CC_EXPORT OutputSurface {
  public:
   struct Capabilities {
     Capabilities() = default;
 
     int max_frames_pending = 1;
     // Whether this output surface renders to the default OpenGL zero
     // framebuffer or to an offscreen framebuffer.
     bool uses_default_gl_framebuffer = true;
     // Whether this OutputSurface is flipped or not.
     bool flipped_output_surface = false;
   };
 
   // Constructor for GL-based compositing.
   explicit OutputSurface(scoped_refptr<ContextProvider> context_provider);
   // Constructor for software compositing.
   explicit OutputSurface(std::unique_ptr<SoftwareOutputDevice> software_device);
   // Constructor for Vulkan-based compositing.
   explicit OutputSurface(
       scoped_refptr<VulkanContextProvider> vulkan_context_provider);
 
-  ~OutputSurface() override;
+  virtual ~OutputSurface();
 
   // Called by the compositor on the compositor thread. This is a place where
   // thread-specific data for the output surface can be initialized, since from
   // this point to when DetachFromClient() is called the output surface will
   // only be used on the compositor thread.
   // The caller should call DetachFromClient() on the same thread before
   // destroying the OutputSurface, even if this fails. And BindToClient should
   // not be called twice for a given OutputSurface.
   virtual bool BindToClient(OutputSurfaceClient* client);
 
@@ skipping 45 matching lines @@
   // Gives the GL internal format that should be used for calling CopyTexImage2D
   // when the framebuffer is bound via BindFramebuffer().
   virtual uint32_t GetFramebufferCopyTextureFormat() = 0;
 
   // The implementation may destroy or steal the contents of the CompositorFrame
   // passed in (though it will not take ownership of the CompositorFrame
   // itself). For successful swaps, the implementation must call
   // OutputSurfaceClient::DidSwapBuffersComplete() eventually.
   virtual void SwapBuffers(OutputSurfaceFrame frame) = 0;
 
-  // base::trace_event::MemoryDumpProvider implementation.
-  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
-                    base::trace_event::ProcessMemoryDump* pmd) override;
-
  protected:
   void PostSwapBuffersComplete();
 
   // Used internally for the context provider to inform the client about loss,
   // and can be overridden to change behaviour instead of informing the client.
   virtual void DidLoseOutputSurface();
 
   OutputSurfaceClient* client_ = nullptr;
 
   struct OutputSurface::Capabilities capabilities_;
@@ skipping 11 matching lines @@
   void OnSwapBuffersComplete();
 
   base::WeakPtrFactory<OutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OutputSurface);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_OUTPUT_SURFACE_H_