memory-infra: Finish moving memory_infra from TracingController

services/resource_coordinator/memory/coordinator/coordinator_impl_unittest.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 "services/resource_coordinator/memory/coordinator/coordinator_impl.h"
 #include "base/bind_helpers.h"
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/resource_coordinator/public/interfaces/memory/memory_instrumentation.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace memory_instrumentation {
 
 class CoordinatorImplTest : public testing::Test {
  public:
   CoordinatorImplTest() {}
   void SetUp() override {
     dump_response_args_ = {static_cast<uint64_t>(-1), false};
+    coordinator_.reset(new CoordinatorImpl());
+    coordinator_->InitializeForTest(base::ThreadTaskRunnerHandle::Get().get());
   }
 
+  void TearDown() override { coordinator_.reset(); }
+
   void RegisterProcessLocalDumpManager(
       mojom::ProcessLocalDumpManagerPtr process_manager) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&CoordinatorImpl::RegisterProcessLocalDumpManager,
-                              base::Unretained(&coordinator_),
+                              base::Unretained(coordinator_.get()),
                               base::Passed(&process_manager)));
   }
 
   void RequestGlobalMemoryDump(base::trace_event::MemoryDumpRequestArgs args,
                                base::Closure closure) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&CoordinatorImpl::RequestGlobalMemoryDump,
-                   base::Unretained(&coordinator_), args,
+                   base::Unretained(coordinator_.get()), args,
                    base::Bind(&CoordinatorImplTest::OnGlobalMemoryDumpResponse,
                               base::Unretained(this), closure)));
   }
 
   void OnGlobalMemoryDumpResponse(base::Closure closure,
                                   uint64_t dump_guid,
                                   bool success) {
     dump_response_args_ = {dump_guid, success};
     closure.Run();
   }
 
  protected:
   struct DumpResponseArgs {
     uint64_t dump_guid;
     bool success;
   };
 
   DumpResponseArgs dump_response_args_;
 
  private:
-  CoordinatorImpl coordinator_;
+  std::unique_ptr<CoordinatorImpl> coordinator_;
   base::MessageLoop message_loop_;
 };
 
 class MockDumpManager : mojom::ProcessLocalDumpManager {
  public:
   MockDumpManager(CoordinatorImplTest* test_coordinator, int expected_calls)
       : binding_(this), expected_calls_(expected_calls) {
     // Register to the coordinator.
     mojom::ProcessLocalDumpManagerPtr process_manager;
     binding_.Bind(mojo::MakeRequest(&process_manager));
@@ skipping 58 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind([](std::unique_ptr<MockDumpManager> dm) {},
                             base::Passed(&dump_manager_2)));
 
   run_loop.Run();
 
   EXPECT_EQ(static_cast<uint64_t>(3456), dump_response_args_.dump_guid);
   EXPECT_FALSE(dump_response_args_.success);
 }
 }  // namespace memory_instrumentation