[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/synchronization/waitable_event.h"
+#include "base/threading/thread.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::MemoryDumpManager;
 using base::trace_event::MemoryDumpType;
 using base::trace_event::ProcessMemoryDump;
 using testing::_;
+using testing::DoAll;
 using testing::Return;
 
 namespace content {
 
+ACTION_P(WaitEvent, event) {
+  event->Wait();
+}
+
 // 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:
@@ skipping 23 matching lines @@
     last_callback_success_ = success;
     closure.Run();
   }
 
  protected:
   void SetUp() override {
     callback_call_count_ = 0;
     last_callback_dump_guid_ = 0;
     last_callback_success_ = false;
 
+    mock_dump_provider_thread_.reset(
+        new base::Thread("MockDumpProvider thread"));
+    EXPECT_TRUE(mock_dump_provider_thread_->Start());
     mock_dump_provider_.reset(new MockDumpProvider());
     MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-        mock_dump_provider_.get(), "MockDumpProvider", nullptr);
+        mock_dump_provider_.get(), "MockDumpProvider",
+        mock_dump_provider_thread_->task_runner());
     MemoryDumpManager::GetInstance()
         ->set_dumper_registrations_ignored_for_testing(false);
     ContentBrowserTest::SetUp();
   }
 
   void TearDown() override {
     MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
         mock_dump_provider_.get());
     mock_dump_provider_.reset();
+    mock_dump_provider_thread_.reset();
     ContentBrowserTest::TearDown();
   }
 
   void EnableMemoryTracing() {
     // Enable tracing without periodic dumps.
     base::trace_event::TraceConfig trace_config(
         base::trace_event::TraceConfigMemoryTestUtil::
             GetTraceConfig_EmptyTriggers());
 
     base::RunLoop run_loop;
     bool success = TracingController::GetInstance()->StartTracing(
       trace_config, run_loop.QuitClosure());
     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;
+  void RequestGlobalDumpWhichQuitsLoop(bool from_renderer_thread,
+                                       base::RunLoop* run_loop) {
     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));
     } else {
       DoRequestGlobalDump(callback);
     }
+  }
+
+  void RequestGlobalDumpAndWait(bool from_renderer_thread) {
+    base::RunLoop run_loop;
+    RequestGlobalDumpWhichQuitsLoop(from_renderer_thread, &run_loop);
     run_loop.Run();
   }
 
   void Navigate(Shell* shell) {
     NavigateToURL(shell, GetTestUrl("", "title.html"));
   }
 
   base::Closure on_memory_dump_complete_closure_;
+  std::unique_ptr<base::Thread> mock_dump_provider_thread_;
   std::unique_ptr<MockDumpProvider> mock_dump_provider_;
   uint32_t callback_call_count_;
   uint64_t last_callback_dump_guid_;
   bool last_callback_success_;
 };
 
 // Ignore SingleProcessMemoryTracingTests for Google Chrome builds because
 // single-process is not supported on those builds.
 #if !defined(GOOGLE_CHROME_BUILD)
 
@@ skipping 60 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, EnqueuedDumps) {
+  Navigate(shell());
+
+  EnableMemoryTracing();
+
+  base::RunLoop loop1;

[Primiano Tucci (use gerrit), 2016/06/16 08:37:23]

never seen this pattern, why do you need 4 run loops?.
I think you want four scopes { RunLoop loop; .... loop.run() }

Also I think you don't need all this cmplexity. As long as you have one MDP 
bound to the same thread, that will necessarily prevent the dump to complete
before you finish the current task (because it depends on task posted next)

[petrcermak, 2016/06/16 12:08:29]

The problem is that I need to do the following:

 REQUEST1 ---------------------------> FINISHED1
             REQUEST2 -----------------------------> FINISHED2
                                 ^
                                 :
Because I'm interested in this ..:

Therefore, the run loops need to overlap.

+  base::RunLoop loop2;
+  base::RunLoop loop3;
+  base::RunLoop loop4;
+
+  // We force all dumps to wait on a waitable event to make sure that they are
+  // indeed queued.
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,

[Primiano Tucci (use gerrit), 2016/06/16 08:37:23]

I think you don't need this waitable event if you just have one MDP bound to the
same thread of this (i.e. ThreadTaskRunnerHandle::Get()

[petrcermak, 2016/06/16 12:08:29]

OK. Just to check: Am I guaranteed that a dump doesn't finish (from
TraceController's point of view) before RequestGlobalMemoryDump exits?

+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
+  EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_, _))
+      .Times(4)
+      .WillRepeatedly(DoAll(WaitEvent(&event), Return(true)));
+
+  RequestGlobalDumpWhichQuitsLoop(false /* from_renderer_thread */, &loop1);
+  RequestGlobalDumpWhichQuitsLoop(true /* from_renderer_thread */, &loop2);
+  RequestGlobalDumpWhichQuitsLoop(false /* from_renderer_thread */, &loop3);
+  RequestGlobalDumpWhichQuitsLoop(true /* from_renderer_thread */, &loop4);
+  EXPECT_EQ(0u, callback_call_count_);
+
+  event.Signal();
+  loop1.Run();
+  EXPECT_EQ(1u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  event.Signal();
+  loop2.Run();
+  EXPECT_EQ(2u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  event.Signal();
+  loop3.Run();
+  EXPECT_EQ(3u, callback_call_count_);
+  EXPECT_NE(0u, last_callback_dump_guid_);
+  EXPECT_TRUE(last_callback_success_);
+
+  event.Signal();
+  loop4.Run();
+  EXPECT_EQ(4u, 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