[tracing] Add separate dump provider for sql connection

sql/connection.h

 // Copyright (c) 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 SQL_CONNECTION_H_
 #define SQL_CONNECTION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
-#include "base/trace_event/memory_dump_provider.h"
 #include "sql/sql_export.h"
 
 struct sqlite3;
 struct sqlite3_stmt;
 
 namespace base {
 class FilePath;
 class HistogramBase;
 }
 
 namespace sql {
 
+class ConnectionMemoryDumpProvider;
 class Recovery;
 class Statement;
 
 // To allow some test classes to be friended.
 namespace test {
 class ScopedCommitHook;
 class ScopedScalarFunction;
 class ScopedMockTimeSource;
 }
 
@@ skipping 52 matching lines @@
   TimeSource() {}
   virtual ~TimeSource() {}
 
   // Return the current time (by default base::TimeTicks::Now()).
   virtual base::TimeTicks Now();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimeSource);
 };
 
-class SQL_EXPORT Connection : public base::trace_event::MemoryDumpProvider {
+class SQL_EXPORT Connection {
  private:
   class StatementRef;  // Forward declaration, see real one below.
 
  public:
   // The database is opened by calling Open[InMemory](). Any uncommitted
   // transactions will be rolled back when this object is deleted.
   Connection();
-  ~Connection() override;
+  ~Connection();
 
   // Pre-init configuration ----------------------------------------------------
 
   // Sets the page size that will be used when creating a new database. This
   // must be called before Init(), and will only have an effect on new
   // databases.
   //
   // From sqlite.org: "The page size must be a power of two greater than or
   // equal to 512 and less than or equal to SQLITE_MAX_PAGE_SIZE. The maximum
   // value for SQLITE_MAX_PAGE_SIZE is 32768."
@@ skipping 350 matching lines @@
   // Clients which provide an error_callback don't see the
   // error-handling at the end of OnSqliteError().  Expose to allow
   // those clients to work appropriately with ScopedErrorIgnorer in
   // tests.
   static bool ShouldIgnoreSqliteError(int error);
 
   // Additionally ignores errors which are unlikely to be caused by problems
   // with the syntax of a SQL statement, or problems with the database schema.
   static bool ShouldIgnoreSqliteCompileError(int error);
 
-  // base::trace_event::MemoryDumpProvider implementation.
-  bool OnMemoryDump(
-      const base::trace_event::MemoryDumpArgs& args,
-      base::trace_event::ProcessMemoryDump* process_memory_dump) override;
-
   // Collect various diagnostic information and post a crash dump to aid
   // debugging.  Dump rate per database is limited to prevent overwhelming the
   // crash server.
   void ReportDiagnosticInfo(int extended_error, Statement* stmt);
 
  private:
   // For recovery module.
   friend class Recovery;
 
   // Allow test-support code to set/reset error ignorer.
   friend class ScopedErrorIgnorer;
 
   // Statement accesses StatementRef which we don't want to expose to everybody
   // (they should go through Statement).
   friend class Statement;
 
   friend class test::ScopedCommitHook;
   friend class test::ScopedScalarFunction;
   friend class test::ScopedMockTimeSource;
 
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, CollectDiagnosticInfo);
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, GetAppropriateMmapSize);
+  FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, OnMemoryDump);
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, RegisterIntentToUpload);
 
   // Internal initialize function used by both Init and InitInMemory. The file
   // name is always 8 bits since we want to use the 8-bit version of
   // sqlite3_open. The string can also be sqlite's special ":memory:" string.
   //
   // |retry_flag| controls retrying the open if the error callback
   // addressed errors using RazeAndClose().
   enum Retry {
     NO_RETRY = 0,
@@ skipping 264 matching lines @@
   // autocommit).
   base::HistogramBase* update_time_histogram_;
 
   // Histogram for tracking time taken in all queries.
   base::HistogramBase* query_time_histogram_;
 
   // Source for timing information, provided to allow tests to inject time
   // changes.
   scoped_ptr<TimeSource> clock_;
 
+  // Stores the dump provider object when db is open.
+  scoped_ptr<ConnectionMemoryDumpProvider> memory_dump_provider_;
+
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_