[tracing] Add separate dump provider for sql connection

sql/connection_memory_dump_provider.cc

Index: sql/connection_memory_dump_provider.cc
diff --git a/sql/connection_memory_dump_provider.cc b/sql/connection_memory_dump_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0284bd0451598da67fb2cddb7b241ba0f6b2d3c6
--- /dev/null
+++ b/sql/connection_memory_dump_provider.cc
@@ -0,0 +1,74 @@
+// Copyright 2015 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.
+
+#include "sql/connection_memory_dump_provider.h"
+
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/process_memory_dump.h"
+#include "third_party/sqlite/sqlite3.h"
+
+namespace sql {
+
+ConnectionMemoryDumpProvider::ConnectionMemoryDumpProvider(
+    sqlite3* db,
+    const std::string& name)
+    : db_(db), connection_name_(name) {}
+
+ConnectionMemoryDumpProvider::~ConnectionMemoryDumpProvider() {}
+
+void ConnectionMemoryDumpProvider::ResetDatabase() {
+  base::AutoLock lock(lock_);
+  db_ = nullptr;
+}
+
+bool ConnectionMemoryDumpProvider::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  if (args.level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::LIGHT)
+    return true;
+
+  int cache_size = 0;
+  int schema_size = 0;
+  int statement_size = 0;
+  {
+    // Lock is acquired here so that db_ is not reset in ResetDatabase when
+    // collecting stats.
+    base::AutoLock lock(lock_);
+    if (!db_) {
+      return false;
+    }
+
+    // The high water mark is not tracked for the following usages.
+    int dummy_int;
+    int status = sqlite3_db_status(db_, SQLITE_DBSTATUS_CACHE_USED, &cache_size,

[michaeln, 2016/01/14 01:37:40]

maybe a comment or check of some kind about SQLITE_THREADSAFE being turned on:  
DCHECK(sqlite3_threadsafe())

[Scott Hess - ex-Googler, 2016/01/21 20:30:07]

SQLITE_THREADSAFE is out of reach, here, but sqlite3_threadsafe() returns
whatever SQLITE_THREADSAFE is in the sqlite compile.

If you were feeling like adding a DCHECK(), though, add it at registration
rather than here, so that it actually fires early enough to matter (this code
might never run in a local build for a variety of reasons, especially if
someone's working on sqlite stuff, not on memory-tracing stuff).

[Actually, we're so dependent on SQLite being thread-safe that I don't think it
matters whether anyone checks this, but another option would be to put it in
sqlite_features_unittest.cc.]

+                                   &dummy_int, 0 /* resetFlag */);
+    DCHECK_EQ(SQLITE_OK, status);
+    status = sqlite3_db_status(db_, SQLITE_DBSTATUS_SCHEMA_USED, &schema_size,
+                               &dummy_int, 0 /* resetFlag */);
+    DCHECK_EQ(SQLITE_OK, status);
+    status = sqlite3_db_status(db_, SQLITE_DBSTATUS_STMT_USED, &statement_size,
+                               &dummy_int, 0 /* resetFlag */);
+    DCHECK_EQ(SQLITE_OK, status);
+  }
+
+  std::string name = base::StringPrintf(
+      "sqlite/%s_connection/%p",
+      connection_name_.empty() ? "Unknown" : connection_name_.c_str(), this);
+  base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(name);
+  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  cache_size + schema_size + statement_size);
+  dump->AddScalar("cache_size",
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  cache_size);
+  dump->AddScalar("schema_size",
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  schema_size);
+  dump->AddScalar("statement_size",
+                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                  statement_size);
+  return true;
+}
+
+}  // namespace sql