Update to Chromium //base at Chromium commit 3e81715e6d3a4324362635aea46ce1f1a163cca1.

trace_event/memory_dump_manager_unittest.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 "base/trace_event/memory_dump_manager.h"
 
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 54 matching lines @@
 
   void DumpCallbackAdapter(scoped_refptr<SingleThreadTaskRunner> task_runner,
                            Closure closure,
                            uint64 dump_guid,
                            bool success) {
     last_callback_success_ = success;
     task_runner->PostTask(FROM_HERE, closure);
   }
 
  protected:
-  const char* kTraceCategory = MemoryDumpManager::kTraceCategoryForTesting;
-
   void EnableTracing(const char* category) {
     TraceLog::GetInstance()->SetEnabled(
         TraceConfig(category, ""), TraceLog::RECORDING_MODE);
   }
 
   void DisableTracing() { TraceLog::GetInstance()->SetDisabled(); }
 
   scoped_ptr<MemoryDumpManager> mdm_;
   bool last_callback_success_;
 
@@ skipping 83 matching lines @@
 
   // Check that the dumper is not called if the memory category is not enabled.
   EnableTracing("foo-and-bar-but-not-memory");
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   DisableTracing();
 
   // Now repeat enabling the memory category and check that the dumper is
   // invoked this time.
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3).WillRepeatedly(Return(true));
   for (int i = 0; i < 3; ++i)
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
   DisableTracing();
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   // Finally check the unregister logic (no calls to the mdp after unregister).
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
   // Check that requesting dumps with high level of detail actually propagates
   // to OnMemoryDump() call on dump providers.
   MockDumpProvider mdp_high_detail(MemoryDumpArgs::LevelOfDetail::HIGH);
   mdm_->RegisterDumpProvider(&mdp_high_detail);
 
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp_high_detail, OnMemoryDump(_, _))
       .Times(1)
       .WillRepeatedly(
           Invoke(&mdp_high_detail,
                  &MockDumpProvider::OnMemoryDump_CheckMemoryDumpArgs));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp_high_detail);
 
   // Check that requesting dumps with low level of detail actually propagates to
   // OnMemoryDump() call on dump providers.
   MockDumpProvider mdp_low_detail(MemoryDumpArgs::LevelOfDetail::LOW);
   mdm_->RegisterDumpProvider(&mdp_low_detail);
 
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp_low_detail, OnMemoryDump(_, _))
       .Times(1)
       .WillRepeatedly(
           Invoke(&mdp_low_detail,
                  &MockDumpProvider::OnMemoryDump_CheckMemoryDumpArgs));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           low_detail_args);
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp_low_detail);
 }
 
 TEST_F(MemoryDumpManagerTest, SharedSessionState) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
   mdm_->RegisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
 
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _))
       .Times(2)
       .WillRepeatedly(
           Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_CheckSessionState));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _))
       .Times(2)
       .WillRepeatedly(
           Invoke(&mdp2, &MockDumpProvider::OnMemoryDump_CheckSessionState));
 
   for (int i = 0; i < 2; ++i)
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
 
   DisableTracing();
 }
 
 TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   // Enable only mdp1.
   mdm_->RegisterDumpProvider(&mdp1);
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   DisableTracing();
 
   // Invert: enable mdp1 and disable mdp2.
   mdm_->UnregisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   DisableTracing();
 
   // Enable both mdp1 and mdp2.
   mdm_->RegisterDumpProvider(&mdp1);
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           high_detail_args);
   DisableTracing();
 }
 
 // Verify that whether OnMemoryDump is called depends only on the current
 // registration state and not on previous registrations and dumps.
 TEST_F(MemoryDumpManagerTest, RegistrationConsistency) {
   MockDumpProvider mdp;
 
   mdm_->RegisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
-    EnableTracing(kTraceCategory);
+    EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
     DisableTracing();
   }
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
-    EnableTracing(kTraceCategory);
+    EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
     DisableTracing();
   }
 
   mdm_->RegisterDumpProvider(&mdp);
   mdm_->UnregisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
-    EnableTracing(kTraceCategory);
+    EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
     DisableTracing();
   }
 
   mdm_->RegisterDumpProvider(&mdp);
   mdm_->UnregisterDumpProvider(&mdp);
   mdm_->RegisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
-    EnableTracing(kTraceCategory);
+    EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
     DisableTracing();
   }
 }
 
 // Checks that the MemoryDumpManager respects the thread affinity when a
 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8
 // threads and registering a MemoryDumpProvider on each of them. At each
 // iteration, one thread is removed, to check the live unregistration logic.
@@ skipping 11 matching lines @@
     threads.back()->Start();
     mdps.push_back(new MockDumpProvider(threads.back()->task_runner()));
     MockDumpProvider* mdp = mdps.back();
     mdm_->RegisterDumpProvider(mdp, threads.back()->task_runner());
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(i)
         .WillRepeatedly(
             Invoke(mdp, &MockDumpProvider::OnMemoryDump_CheckTaskRunner));
   }
 
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
 
   while (!threads.empty()) {
     last_callback_success_ = false;
     {
       RunLoop run_loop;
       MemoryDumpCallback callback =
           Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
                MessageLoop::current()->task_runner(), run_loop.QuitClosure());
       mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                               high_detail_args, callback);
@@ skipping 24 matching lines @@
 }
 
 // Enable both dump providers, make sure that mdp gets disabled after 3 failures
 // and not disabled after 1.
 TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   mdm_->RegisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
 
   EXPECT_CALL(mdp1, OnMemoryDump(_, _))
       .Times(MemoryDumpManager::kMaxConsecutiveFailuresCount)
       .WillRepeatedly(Return(false));
 
   EXPECT_CALL(mdp2, OnMemoryDump(_, _))
       .Times(1 + MemoryDumpManager::kMaxConsecutiveFailuresCount)
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   for (int i = 0; i < 1 + MemoryDumpManager::kMaxConsecutiveFailuresCount;
        i++) {
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args);
   }
 
   DisableTracing();
 }
 
 // Sneakily register an extra memory dump provider while an existing one is
 // dumping and expect it to take part in the already active tracing session.
 TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   mdp1.dump_provider_to_register_or_unregister = &mdp2;
   mdm_->RegisterDumpProvider(&mdp1);
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
 
   EXPECT_CALL(mdp1, OnMemoryDump(_, _))
       .Times(4)
       .WillOnce(Return(true))
       .WillOnce(Invoke(
           &mdp1, &MockDumpProvider::OnMemoryDump_RegisterExtraDumpProvider))
       .WillRepeatedly(Return(true));
 
   // Depending on the insertion order (before or after mdp1), mdp2 might be
   // called also immediately after it gets registered.
@@ skipping 10 matching lines @@
 }
 
 // Like the above, but suddenly unregister the dump provider.
 TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   mdm_->RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get());
   mdm_->RegisterDumpProvider(&mdp2, ThreadTaskRunnerHandle::Get());
   mdp1.dump_provider_to_register_or_unregister = &mdp2;
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
 
   EXPECT_CALL(mdp1, OnMemoryDump(_, _))
       .Times(4)
       .WillOnce(Return(true))
       .WillOnce(
           Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_UnregisterDumpProvider))
       .WillRepeatedly(Return(true));
 
   // Depending on the insertion order (before or after mdp1), mdp2 might have
   // been already called when OnMemoryDump_UnregisterDumpProvider happens.
@@ skipping 44 matching lines @@
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(AtMost(1))
         .WillOnce(Invoke(on_dump));
   }
 
   last_callback_success_ = false;
   MemoryDumpCallback callback =
       Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
            MessageLoop::current()->task_runner(), run_loop.QuitClosure());
 
-  EnableTracing(kTraceCategory);
+  EnableTracing(MemoryDumpManager::kTraceCategory);
   MemoryDumpRequestArgs request_args = {0, MemoryDumpType::EXPLICITLY_TRIGGERED,
                                         high_detail_args};
   mdm_->CreateProcessDump(request_args, callback);
 
   run_loop.Run();
 
   ASSERT_EQ(1, on_memory_dump_call_count);
   ASSERT_EQ(true, last_callback_success_);
 
   DisableTracing();
@@ skipping 15 matching lines @@
              MessageLoop::current()->task_runner(), run_loop.QuitClosure());
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             high_detail_args, callback);
     run_loop.Run();
   }
   EXPECT_FALSE(last_callback_success_);
 }
 
 }  // namespace trace_event
 }  // namespace base