Use SequencedWorkerPoolOwner in MemoryDumpManagerTest.

MemoryDumpManagerTest didn't join its thread. This made a write in
TearDown() racy with a read from a thread created by the test.

With this CL, threads created by MemoryDumpManagerTest are joined
before TearDown() runs.

BUG=658766

Review-Url: https://codereview.chromium.org/2447853002
Cr-Commit-Position: refs/heads/master@{#427251}

base/test/sequenced_worker_pool_owner.cc

@@ -28,7 +28,8 @@ SequencedWorkerPoolOwner::~SequencedWorkerPoolOwner() {
   exit_loop_.Run();
 }
 
-const scoped_refptr<SequencedWorkerPool>& SequencedWorkerPoolOwner::pool() {
+const scoped_refptr<SequencedWorkerPool>& SequencedWorkerPoolOwner::pool()
+    const {
   return pool_;
 }
 

base/test/sequenced_worker_pool_owner.h

@@ -39,7 +39,7 @@ class SequencedWorkerPoolOwner : public SequencedWorkerPool::TestingObserver {
   ~SequencedWorkerPoolOwner() override;
 
   // Don't change the returned pool's testing observer.
-  const scoped_refptr<SequencedWorkerPool>& pool();
+  const scoped_refptr<SequencedWorkerPool>& pool() const;
 
   // The given callback will be called on WillWaitForShutdown().
   void SetWillWaitForShutdownCallback(const Closure& callback);

base/trace_event/memory_dump_manager_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/test_io_thread.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/threading/platform_thread.h"
@@ -162,9 +163,7 @@ class MockMemoryDumpProvider : public MemoryDumpProvider {
 class TestSequencedTaskRunner : public SequencedTaskRunner {
  public:
   TestSequencedTaskRunner()
-      : worker_pool_(new SequencedWorkerPool(2 /* max_threads */,
-                                             "Test Task Runner",
-                                             base::TaskPriority::USER_VISIBLE)),
+      : worker_pool_(2 /* max_threads */, "Test Task Runner"),
         enabled_(true),
         num_of_post_tasks_(0) {}
 
@@ -182,19 +181,21 @@ class TestSequencedTaskRunner : public SequencedTaskRunner {
                        const Closure& task,
                        TimeDelta delay) override {
     num_of_post_tasks_++;
-    if (enabled_)
-      return worker_pool_->PostSequencedWorkerTask(token_, from_here, task);
+    if (enabled_) {
+      return worker_pool_.pool()->PostSequencedWorkerTask(token_, from_here,
+                                                          task);
+    }
     return false;
   }
 
   bool RunsTasksOnCurrentThread() const override {
-    return worker_pool_->RunsTasksOnCurrentThread();
+    return worker_pool_.pool()->RunsTasksOnCurrentThread();
   }
 
  private:
   ~TestSequencedTaskRunner() override {}
 
-  scoped_refptr<SequencedWorkerPool> worker_pool_;
+  SequencedWorkerPoolOwner worker_pool_;
   const SequencedWorkerPool::SequenceToken token_;
   bool enabled_;
   unsigned num_of_post_tasks_;