[memory-infra] Add support for queueing memory dump requests in the browser process

content/browser/tracing/memory_tracing_browsertest.cc

 // 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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/trace_config_memory_test_util.h"
 #include "content/public/browser/tracing_controller.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::trace_event::MemoryDumpArgs;
+using base::trace_event::MemoryDumpLevelOfDetail;
 using base::trace_event::MemoryDumpManager;
 using base::trace_event::MemoryDumpType;
 using base::trace_event::ProcessMemoryDump;
 using testing::_;
 using testing::Return;
 
 namespace content {
 
 // A mock dump provider, used to check that dump requests actually end up
 // creating memory dumps.
 class MockDumpProvider : public base::trace_event::MemoryDumpProvider {
  public:
   MOCK_METHOD2(OnMemoryDump, bool(const MemoryDumpArgs& args,
                                   ProcessMemoryDump* pmd));
 };
 
 class MemoryTracingTest : public ContentBrowserTest {
  public:
-  void DoRequestGlobalDump(const base::trace_event::MemoryDumpCallback& cb) {
-    MemoryDumpManager::GetInstance()->RequestGlobalDump(
-        MemoryDumpType::EXPLICITLY_TRIGGERED,
-        base::trace_event::MemoryDumpLevelOfDetail::DETAILED, cb);
+  void DoRequestGlobalDump(const MemoryDumpType& dump_type,
+                           const MemoryDumpLevelOfDetail& level_of_detail,
+                           const base::trace_event::MemoryDumpCallback& cb) {
+    MemoryDumpManager::GetInstance()->RequestGlobalDump(dump_type,
+                                                        level_of_detail, cb);
   }
 
   // Used as callback argument for MemoryDumpManager::RequestGlobalDump():
   void OnGlobalMemoryDumpDone(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       base::Closure closure,
       uint64_t dump_guid,
       bool success) {
     // Make sure we run the RunLoop closure on the same thread that originated
     // the run loop (which is the IN_PROC_BROWSER_TEST_F main thread).
@@ skipping 43 matching lines @@
     EXPECT_TRUE(success);
     run_loop.Run();
   }
 
   void DisableTracing() {
     bool success = TracingController::GetInstance()->StopTracing(NULL);
     EXPECT_TRUE(success);
     base::RunLoop().RunUntilIdle();
   }
 
-  void RequestGlobalDumpAndWait(bool from_renderer_thread) {
-    base::RunLoop run_loop;
+  std::unique_ptr<base::RunLoop> RequestGlobalDumpWhichQuitsLoop(
+      bool from_renderer_thread,
+      const MemoryDumpType& dump_type,
+      const MemoryDumpLevelOfDetail& level_of_detail) {
+    std::unique_ptr<base::RunLoop> run_loop;
+    run_loop.reset(new base::RunLoop());
     base::trace_event::MemoryDumpCallback callback = base::Bind(
         &MemoryTracingTest::OnGlobalMemoryDumpDone, base::Unretained(this),
-        base::ThreadTaskRunnerHandle::Get(), run_loop.QuitClosure());
+        base::ThreadTaskRunnerHandle::Get(), run_loop->QuitClosure());
     if (from_renderer_thread) {
-      PostTaskToInProcessRendererAndWait(
-          base::Bind(&MemoryTracingTest::DoRequestGlobalDump,
-                     base::Unretained(this), callback));
+      PostTaskToInProcessRendererAndWait(base::Bind(
+          &MemoryTracingTest::DoRequestGlobalDump, base::Unretained(this),
+          dump_type, level_of_detail, callback));
     } else {
-      DoRequestGlobalDump(callback);
+      DoRequestGlobalDump(dump_type, level_of_detail, callback);
     }
-    run_loop.Run();
+    return run_loop;
+  }
+
+  void RequestGlobalDumpAndWait(bool from_renderer_thread) {
+    std::unique_ptr<base::RunLoop> run_loop = RequestGlobalDumpWhichQuitsLoop(
+        from_renderer_thread, MemoryDumpType::EXPLICITLY_TRIGGERED,
+        MemoryDumpLevelOfDetail::DETAILED);
+    run_loop->Run();
   }
 
   void Navigate(Shell* shell) {
     NavigateToURL(shell, GetTestUrl("", "title.html"));
   }
 
   base::Closure on_memory_dump_complete_closure_;
   std::unique_ptr<MockDumpProvider> mock_dump_provider_;
   uint32_t callback_call_count_;
   uint64_t last_callback_dump_guid_;
@@ skipping 67 matching lines @@
   EXPECT_TRUE(last_callback_success_);
 
   RequestGlobalDumpAndWait(true /* from_renderer_thread */);
   EXPECT_EQ(4u, callback_call_count_);
   EXPECT_NE(0u, last_callback_dump_guid_);
   EXPECT_TRUE(last_callback_success_);
 
   DisableTracing();
 }
 
+IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, QueuedDumps) {

[ssid, 2016/06/16 23:12:03]

I am removing SingleProcessMemoryTracingTest in this CL
https://codereview.chromium.org/2047533002/

Is there a reason you need a single process test here? Why won't a multi process
test work here?

[petrcermak, 2016/06/17 08:36:44]

Not that I'm aware of, I just followed what the other tests did.

[ssid, 2016/06/17 18:43:45]

Sorry, I got confused with the test files here. Ignore my comment, this looks
good.

[Primiano Tucci (use gerrit), 2016/06/23 11:09:16]

Had a chat offline on this. Let's simplify it

Req(PL)   true
Req(PL)   false
ReqANdWait(PL) falsew

Req(PL) true 
Req(PL)  false
ReqANdWait(PL) false

--------------

Req(EL)  true
Req(PL)  false
ReqAndWait(EL)  True
ReqAndWait(PL)  true

[petrcermak, 2016/06/24 10:49:57]

Done (but kept everything in one test).

+  Navigate(shell());
+
+  EnableMemoryTracing();
+
+  // This test issues the following 6 global memory dump requests:
+  //
+  //   loop1 (ED)  req---------------------------------->ok
+  //   loop2 (PD)      req->fail(1)
+  //   loop3 (PL)                   req-------------------->ok
+  //   loop4 (PL)                       req->fail(3)
+  //   loop5 (ED)                                    req-------------->ok
+  //   loop6 (PL)                                              req->ok
+  //
+  // where P=PERIODIC_INTERVAL, E=EXPLICITLY_TRIGGERED, D=DETAILED and L=LIGHT.
+
+  EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_, _))
+      .Times(4)
+      .WillRepeatedly(Return(true));
+
+  std::unique_ptr<base::RunLoop> loop1 = RequestGlobalDumpWhichQuitsLoop(
+      true /* from_renderer_thread */, MemoryDumpType::EXPLICITLY_TRIGGERED,
+      MemoryDumpLevelOfDetail::DETAILED);
+  EXPECT_EQ(0u, callback_call_count_);
+
+  // This periodic request should immediately fail because there already is a
+  // request for a detailed memory dump on the queue (loop1).
+  std::unique_ptr<base::RunLoop> loop2 = RequestGlobalDumpWhichQuitsLoop(
+      false /* from_renderer_thread */, MemoryDumpType::PERIODIC_INTERVAL,
+      MemoryDumpLevelOfDetail::DETAILED);
+  loop2->Run();
+  EXPECT_EQ(1u, callback_call_count_);
+  EXPECT_FALSE(last_callback_success_);
+
+  std::unique_ptr<base::RunLoop> loop3 = RequestGlobalDumpWhichQuitsLoop(
+      false /* from_renderer_thread */, MemoryDumpType::PERIODIC_INTERVAL,
+      MemoryDumpLevelOfDetail::LIGHT);
+  EXPECT_EQ(1u, callback_call_count_);
+
+  // This periodic request should immediately fail because there already is a
+  // request for a light memory dump on the queue (loop3).
+  std::unique_ptr<base::RunLoop> loop4 = RequestGlobalDumpWhichQuitsLoop(
+      true /* from_renderer_thread */, MemoryDumpType::PERIODIC_INTERVAL,
+      MemoryDumpLevelOfDetail::LIGHT);
+  loop4->Run();
+  EXPECT_EQ(2u, callback_call_count_);
+  EXPECT_FALSE(last_callback_success_);
+
+  std::unique_ptr<base::RunLoop> loop5 = RequestGlobalDumpWhichQuitsLoop(
+      false /* from_renderer_thread */, MemoryDumpType::EXPLICITLY_TRIGGERED,
+      MemoryDumpLevelOfDetail::DETAILED);
+  EXPECT_EQ(2u, callback_call_count_);
+
+  loop1->Run();
+  EXPECT_EQ(3u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  loop3->Run();
+  EXPECT_EQ(4u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  std::unique_ptr<base::RunLoop> loop6 = RequestGlobalDumpWhichQuitsLoop(
+      false /* from_renderer_thread */, MemoryDumpType::PERIODIC_INTERVAL,
+      MemoryDumpLevelOfDetail::LIGHT);
+
+  loop5->Run();
+  EXPECT_EQ(5u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  loop6->Run();
+  EXPECT_EQ(6u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  DisableTracing();
+}
+
 #endif  // !defined(GOOGLE_CHROME_BUILD)
 
 // Non-deterministic races under TSan. crbug.com/529678
 #if defined(THREAD_SANITIZER)
 #define MAYBE_BrowserInitiatedDump DISABLED_BrowserInitiatedDump
 #else
 #define MAYBE_BrowserInitiatedDump BrowserInitiatedDump
 #endif
 // Checks that a memory dump initiated from a the main browser thread ends up in
 // a successful dump.
 IN_PROC_BROWSER_TEST_F(MemoryTracingTest, MAYBE_BrowserInitiatedDump) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_)).WillOnce(Return(true));
 
   EnableMemoryTracing();
   RequestGlobalDumpAndWait(false /* from_renderer_thread */);
   EXPECT_EQ(1u, callback_call_count_);
   EXPECT_NE(0u, last_callback_dump_guid_);
   EXPECT_TRUE(last_callback_success_);
   DisableTracing();
 }
 
 }  // namespace content