Instrument SourceStream using MemoryDumpProvider

net/filter/filter_source_stream.h

 // Copyright 2016 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 NET_FILTER_FILTER_SOURCE_STREAM_H_
 #define NET_FILTER_FILTER_SOURCE_STREAM_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/filter/source_stream.h"
 
+namespace base {
+namespace trace_event {
+class ProcessMemoryDump;
+}
+}
+
 namespace net {
 
 class DrainableIOBuffer;
 class IOBuffer;
 
 // FilterSourceStream represents SourceStreams that always have an upstream
 // from which undecoded input can be read. Except the ultimate upstream in
 // the filter chain, all other streams should implement FilterSourceStream
 // instead of SourceStream.
 class NET_EXPORT_PRIVATE FilterSourceStream : public SourceStream {
  public:
   // |upstream| is the SourceStream from which |this| will read data.
   // |upstream| cannot be null.
   FilterSourceStream(SourceType type, std::unique_ptr<SourceStream> upstream);
 
   ~FilterSourceStream() override;
 
   int Read(IOBuffer* read_buffer,
            int read_buffer_size,
            const CompletionCallback& callback) override;
 
   std::string Description() const override;
 
+  void DumpMemoryStats(
+      base::trace_event::ProcessMemoryDump* dump,
+      const std::string& parent_dump_absolute_name) const override;
+
  private:
   enum State {
     STATE_NONE,
     // Reading data from |upstream_| into |input_buffer_|.
     STATE_READ_DATA,
     // Reading data from |upstream_| completed.
     STATE_READ_DATA_COMPLETE,
     // Filtering data contained in |input_buffer_|.
     STATE_FILTER_DATA,
     // Filtering data contained in |input_buffer_| completed.
@@ skipping 20 matching lines @@
   // with |upstream_eof_reached| = true.
   // TODO(xunjieli): consider allowing asynchronous response via callback
   // to support off-thread decompression.
   virtual int FilterData(IOBuffer* output_buffer,
                          int output_buffer_size,
                          IOBuffer* input_buffer,
                          int input_buffer_size,
                          int* consumed_bytes,
                          bool upstream_eof_reached) = 0;
 
+  // Subclasses can implement this method to dump memory allocation stats.
+  // Subclasses should override this method instead of DumpMemoryStats
+  // so the whole chain of FilterSourceStream can be accounted for.
+  virtual void DumpMemoryStatsImpl(
+      base::trace_event::ProcessMemoryDump* dump,
+      const std::string& parent_dump_absolute_name) const;
+
   // Returns a string representation of the type of this FilterSourceStream.
   // This is for UMA logging.
   virtual std::string GetTypeAsString() const = 0;
 
   // Returns whether |this| still needs more input data from |upstream_|.
   // By default, |this| will continue reading until |upstream_| returns an error
   // or EOF. Subclass can override this to return false to skip reading all the
   // input from |upstream_|.
   virtual bool NeedMoreData() const;
 
@@ skipping 19 matching lines @@
 
   // Reading from |upstream_| has returned 0 byte or an error code.
   bool upstream_end_reached_;
 
   DISALLOW_COPY_AND_ASSIGN(FilterSourceStream);
 };
 
 }  // namespace net
 
 #endif  // NET_FILTER_FILTER_SOURCE_STREAM_H_