Instrument SdchManager using MemoryDumpProvider

net/base/sdch_manager_unittest.cc

 // Copyright 2014 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 "net/base/sdch_manager.h"
 
 #include <limits.h>
 
 #include <memory>
 #include <string>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
+#include "base/trace_event/memory_allocator_dump.h"
+#include "base/trace_event/process_memory_dump.h"
+#include "base/trace_event/trace_event_argument.h"
 #include "net/base/sdch_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 //------------------------------------------------------------------------------
 // Provide sample data and compression results with a sample VCDIFF dictionary.
 // Note an SDCH dictionary has extra meta-data before the VCDIFF dictionary.
 static const char kTestVcdiffDictionary[] = "DictionaryFor"
@@ skipping 603 matching lines @@
   EXPECT_EQ(target_gurl, observer.last_dictionary_url());
   EXPECT_EQ(server_hash, observer.last_server_hash());
 
   EXPECT_EQ(SDCH_OK, sdch_manager()->RemoveSdchDictionary(server_hash));
   EXPECT_EQ(1, observer.dictionary_removed_notifications());
   EXPECT_EQ(server_hash, observer.last_server_hash());
 
   sdch_manager()->RemoveObserver(&observer);
 }
 
+TEST_F(SdchManagerTest, DumpMemoryStats) {
+  MockSdchObserver observer;
+  sdch_manager()->AddObserver(&observer);
+
+  std::string dictionary_domain("x.y.z.google.com");
+  GURL target_gurl("http://" + dictionary_domain);
+  std::string dictionary_text(NewSdchDictionary(dictionary_domain));
+  std::string client_hash;
+  std::string server_hash;
+  SdchManager::GenerateHash(dictionary_text, &client_hash, &server_hash);
+  EXPECT_TRUE(AddSdchDictionary(dictionary_text, target_gurl));
+  EXPECT_EQ(1, observer.dictionary_added_notifications());
+  EXPECT_EQ(target_gurl, observer.last_dictionary_url());
+  EXPECT_EQ(server_hash, observer.last_server_hash());
+
+  base::trace_event::MemoryDumpArgs dump_args = {
+      base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
+  std::unique_ptr<base::trace_event::ProcessMemoryDump> pmd(
+      new base::trace_event::ProcessMemoryDump(nullptr, dump_args));
+
+  base::trace_event::MemoryAllocatorDump* parent =
+      pmd->CreateAllocatorDump("parent");
+  sdch_manager()->DumpMemoryStats(pmd.get(), parent->absolute_name());
+
+  const base::trace_event::MemoryAllocatorDump* sub_dump =
+      pmd->GetAllocatorDump("parent/sdch_manager");
+  ASSERT_NE(nullptr, sub_dump);
+  const base::trace_event::MemoryAllocatorDump* dump = pmd->GetAllocatorDump(
+      base::StringPrintf("net/sdch_manager_%p", sdch_manager()));
+  std::unique_ptr<base::Value> raw_attrs =
+      dump->attributes_for_testing()->ToBaseValue();
+  base::DictionaryValue* attrs;
+  ASSERT_TRUE(raw_attrs->GetAsDictionary(&attrs));
+  ASSERT_TRUE(attrs->HasKey(base::trace_event::MemoryAllocatorDump::kNameSize));
+  base::DictionaryValue* count_attrs;
+  ASSERT_TRUE(attrs->GetDictionary(
+      base::trace_event::MemoryAllocatorDump::kNameObjectCount, &count_attrs));
+  std::string count;
+  ASSERT_TRUE(count_attrs->GetString("value", &count));
+  // One dictionary.
+  ASSERT_EQ("1", count);

[Randy Smith (Not in Mondays), 2016/12/21 20:21:38]

I'd feel better if there was some test that compared the amount of memory
charged against the manager with the size of dictionary_text.  Is there a reason
not to do that?

[Randy Smith (Not in Mondays), 2016/12/21 20:21:38]

Why not EXPECT_EQ for this one?  I think we want the observer to be removed even
if the counts off.

[xunjieli, 2016/12/22 16:06:35]

Done.

[xunjieli, 2016/12/22 16:06:35]

Done.

+
+  sdch_manager()->RemoveObserver(&observer);
+}
+
 }  // namespace net