[memory-infra] Trigger first periodic dump after initial period

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/callback_forward.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
+#include "base/synchronization/waitable_event.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 "base/trace_event/trace_log.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 {
+namespace {
+
+void OnStartTracingDoneCallback(base::Closure quit_loop,
+                                base::WaitableEvent* evt) {
+  quit_loop.Run();
+  if (evt)

[chiniforooshan, 2017/04/12 19:32:57]

I know that BrowserInitiatedDump is flaky because the global dump request is
sent before tracing is enabled on all processes, but I don't understand why the
signalling changes anything. Doesn't the EnableMemoryTracing wait until the quit
closure is run?

[ssid, 2017/04/12 20:03:18]

Yes, you are right! I just realized both the tests have runloop till tracing is
enabled.

+    evt->Signal();
+}
+}
 
 // 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 {
@@ skipping 59 matching lines @@
     ContentBrowserTest::SetUp();
   }
 
   void TearDown() override {
     MemoryDumpManager::GetInstance()->UnregisterAndDeleteDumpProviderSoon(
         std::move(mock_dump_provider_));
     mock_dump_provider_.reset();
     ContentBrowserTest::TearDown();
   }
 
-  void EnableMemoryTracing() {
+  void EnableMemoryTracing(base::WaitableEvent* start_tracing_done_signal) {
     // Re-enabling tracing could crash these tests https://crbug.com/657628 .
     if (base::trace_event::TraceLog::GetInstance()->IsEnabled()) {
       FAIL() << "Tracing seems to be already enabled. "
                 "Very likely this is because the startup tracing file "
                 "has been leaked from a previous test.";
     }
     // 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());
+        trace_config,
+        base::Bind(&OnStartTracingDoneCallback, run_loop.QuitClosure(),
+                   start_tracing_done_signal));
     EXPECT_TRUE(success);
     run_loop.Run();
   }
 
   void DisableTracing() {
     bool success = TracingController::GetInstance()->StopTracing(NULL);
     EXPECT_TRUE(success);
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 41 matching lines @@
 
 // Checks that a memory dump initiated from a the main browser thread ends up in
 // a single dump even in single process mode.
 IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest,
                        BrowserInitiatedSingleDump) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_)).WillOnce(Return(true));
   EXPECT_CALL(*this, OnMemoryDumpDone(_, true /* success */));
 
-  EnableMemoryTracing();
+  EnableMemoryTracing(nullptr /* start_tracing_done_signal */);
   RequestGlobalDumpAndWait(false /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   DisableTracing();
 }
 
 // Checks that a memory dump initiated from a renderer thread ends up in a
 // single dump even in single process mode.
 IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest,
                        RendererInitiatedSingleDump) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_)).WillOnce(Return(true));
   EXPECT_CALL(*this, OnMemoryDumpDone(_, true /* success */));
 
-  EnableMemoryTracing();
+  EnableMemoryTracing(nullptr /* start_tracing_done_signal */);
   RequestGlobalDumpAndWait(true /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   DisableTracing();
 }
 
 IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, ManyInterleavedDumps) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_))
       .Times(4)
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*this, OnMemoryDumpDone(_, true /* success */)).Times(4);
 
-  EnableMemoryTracing();
+  EnableMemoryTracing(nullptr /* start_tracing_done_signal */);
   RequestGlobalDumpAndWait(true /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   RequestGlobalDumpAndWait(false /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   RequestGlobalDumpAndWait(false /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   RequestGlobalDumpAndWait(true /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   DisableTracing();
 }
 
 // Checks that, if there already is a memory dump in progress, subsequent memory
 // dump requests are queued and carried out after it's finished. Also checks
 // that periodic dump requests fail in case there is already a request in the
 // queue with the same level of detail.
 IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, QueuedDumps) {
   Navigate(shell());
 
-  EnableMemoryTracing();
+  EnableMemoryTracing(nullptr /* start_tracing_done_signal */);
 
   // Issue the following 6 global memory dump requests:
   //
   //   0 (ED)  req-------------------------------------->ok
   //   1 (PD)      req->fail(0)
   //   2 (PL)                   req------------------------>ok
   //   3 (PL)                       req->fail(2)
   //   4 (EL)                                    req---------->ok
   //   5 (ED)                                        req--------->ok
   //   6 (PL)                                                        req->ok
@@ skipping 41 matching lines @@
   EXPECT_CALL(*this, OnMemoryDumpDone(6, true /* success */));
   RequestGlobalDumpAndWait(true /* from_renderer_thread */,
                            MemoryDumpType::PERIODIC_INTERVAL,
                            MemoryDumpLevelOfDetail::LIGHT);
 
   DisableTracing();
 }
 
 #endif  // !defined(GOOGLE_CHROME_BUILD)
 
-// Non-deterministic races under TSan. crbug.com/529678
-// Flaky on Linux. crbug.com/709524
-#if defined(THREAD_SANITIZER) || defined(OS_LINUX)
-#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) {
+IN_PROC_BROWSER_TEST_F(MemoryTracingTest, BrowserInitiatedDump) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_)).WillOnce(Return(true));
   EXPECT_CALL(*this, OnMemoryDumpDone(_, true /* success */));
 
-  EnableMemoryTracing();
+  base::WaitableEvent start_tracing_done(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  EnableMemoryTracing(&start_tracing_done);
+
+  // Wait till child processes gets tracing enabled signal.
+  start_tracing_done.Wait();
   RequestGlobalDumpAndWait(false /* from_renderer_thread */,
                            MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   DisableTracing();
 }
 
 }  // namespace content