content: Always run EnforceMemoryPolicy() callbacks on the same thread.

content/common/host_discardable_shared_memory_manager.cc

 // Copyright 2014 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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 105 matching lines @@
           std::min(base::SysInfo::AmountOfPhysicalMemory() / 4,
                    base::SysInfo::IsLowEndDevice()
                        ?
                        // Use 1/8th of discardable memory on low-end devices.
                        kMaxDefaultMemoryLimit / 8
                        : kMaxDefaultMemoryLimit)),
       bytes_allocated_(0),
       memory_pressure_listener_(new base::MemoryPressureListener(
           base::Bind(&HostDiscardableSharedMemoryManager::OnMemoryPressure,
                      base::Unretained(this)))),
+      // Current thread might not have a task runner in tests.
+      enforce_memory_policy_task_runner_(
+          base::ThreadTaskRunnerHandle::IsSet()
+              ? base::ThreadTaskRunnerHandle::Get()
+              : nullptr),
       enforce_memory_policy_pending_(false),
       weak_ptr_factory_(this) {
   DCHECK_NE(memory_limit_, 0u);
+  enforce_memory_policy_callback_ =
+      base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
+                 weak_ptr_factory_.GetWeakPtr());
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this);
 }
 
 HostDiscardableSharedMemoryManager::~HostDiscardableSharedMemoryManager() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 HostDiscardableSharedMemoryManager*
@@ skipping 340 matching lines @@
   return base::Time::Now();
 }
 
 void HostDiscardableSharedMemoryManager::ScheduleEnforceMemoryPolicy() {
   lock_.AssertAcquired();
 
   if (enforce_memory_policy_pending_)
     return;
 
   enforce_memory_policy_pending_ = true;
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
-                 weak_ptr_factory_.GetWeakPtr()),
+  DCHECK(enforce_memory_policy_task_runner_);
+  enforce_memory_policy_task_runner_->PostDelayedTask(
+      FROM_HERE, enforce_memory_policy_callback_,
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content