Reland of Linux: Disable DBus auto-launch

net/url_request/url_request_quic_perftest.cc

 // Copyright 2017 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 <inttypes.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/time/time.h"
 #include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/memory_dump_manager_test_utils.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_config.h"
 #include "base/trace_event/trace_config_memory_test_util.h"
 #include "base/trace_event/trace_log.h"
 #include "net/base/load_timing_info.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 48 matching lines @@
 void PrintPerfTest(const std::string& name,
                    int value,
                    const std::string& unit) {
   const ::testing::TestInfo* test_info =
       ::testing::UnitTest::GetInstance()->current_test_info();
   perf_test::PrintResult(test_info->test_case_name(),
                          std::string(".") + test_info->name(), name,
                          static_cast<double>(value), unit, true);
 }
 
-void RequestGlobalDumpCallback(base::Closure quit_closure,
-                               uint64_t,
-                               bool success) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
-  ASSERT_TRUE(success);
-}
-
-void ProcessDumpCallbackAdapter(
-    base::trace_event::GlobalMemoryDumpCallback callback,
-    uint64_t dump_guid,
-    bool success,
-    const base::Optional<base::trace_event::MemoryDumpCallbackResult>&) {
-  callback.Run(dump_guid, success);
-}
-
-void RequestGlobalMemoryDumpCallback(
-    const base::trace_event::MemoryDumpRequestArgs& args,
-    const base::trace_event::GlobalMemoryDumpCallback& callback) {
-  base::trace_event::ProcessMemoryDumpCallback process_callback =
-      base::Bind(&ProcessDumpCallbackAdapter, callback);
-  base::trace_event::MemoryDumpManager::GetInstance()->CreateProcessDump(
-      args, process_callback);
-}
-
 class URLRequestQuicPerfTest : public ::testing::Test {
  protected:
   URLRequestQuicPerfTest() : message_loop_(new base::MessageLoopForIO()) {
     memory_dump_manager_ =
         base::trace_event::MemoryDumpManager::CreateInstanceForTesting();
-    memory_dump_manager_->Initialize(
-        base::BindRepeating(&RequestGlobalMemoryDumpCallback),
+    base::trace_event::InitializeMemoryDumpManagerForInProcessTesting(
         /*is_coordinator_process=*/false);
     memory_dump_manager_->set_dumper_registrations_ignored_for_testing(false);
     context_ = base::MakeUnique<TestURLRequestContext>(true);
     memory_dump_manager_->set_dumper_registrations_ignored_for_testing(true);
     StartTcpServer();
     StartQuicServer();
 
     // Host mapping.
     std::unique_ptr<MockHostResolver> resolver(new MockHostResolver());
     resolver->rules()->AddRule(kAltSvcHost, "127.0.0.1");
@@ skipping 131 matching lines @@
   base::TimeTicks end = base::TimeTicks::Now();
   PrintPerfTest("time", (end - start).InMilliseconds() / kNumRequest, "ms");
 
   EXPECT_TRUE(quic_succeeded);
   base::trace_event::TraceLog::GetInstance()->SetEnabled(
       base::trace_event::TraceConfig(
           base::trace_event::MemoryDumpManager::kTraceCategory, ""),
       base::trace_event::TraceLog::RECORDING_MODE);
 
   base::RunLoop run_loop;
-  base::trace_event::MemoryDumpManager::GetInstance()->RequestGlobalDump(
-      base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
-      base::trace_event::MemoryDumpLevelOfDetail::LIGHT,
-      base::Bind(&RequestGlobalDumpCallback, run_loop.QuitClosure()));
-
+  base::trace_event::MemoryDumpRequestArgs args{
+      1 /* dump_guid*/, base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
+      base::trace_event::MemoryDumpLevelOfDetail::LIGHT};
+  auto on_memory_dump_done =
+      [](base::Closure quit_closure, uint64_t dump_guid, bool success,
+         const base::Optional<base::trace_event::MemoryDumpCallbackResult>&) {
+        base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
+        ASSERT_TRUE(success);
+      };
+  base::trace_event::MemoryDumpManager::GetInstance()->CreateProcessDump(
+      args, base::Bind(on_memory_dump_done, run_loop.QuitClosure()));
   run_loop.Run();
   base::trace_event::TraceLog::GetInstance()->SetDisabled();
   std::unique_ptr<trace_analyzer::TraceAnalyzer> analyzer =
       GetDeserializedTrace();
 
   trace_analyzer::TraceEventVector events;
   analyzer->FindEvents(
       trace_analyzer::Query::EventPhaseIs(TRACE_EVENT_PHASE_MEMORY_DUMP),
       &events);
   EXPECT_EQ(
@@ skipping 49 matching lines @@
   base::DictionaryValue* http_stream_factory_dump;
   ASSERT_FALSE(allocator_dumps->GetDictionary(
       base::StringPrintf(
           "net/http_network_session_0x%" PRIxPTR "/stream_factory",
           reinterpret_cast<uintptr_t>(
               context()->http_transaction_factory()->GetSession())),
       &http_stream_factory_dump));
 }
 
 }  // namespace net