Remove MessageLoop::current() from chrome_metrics_service_client.cc

content/browser/histogram_synchronizer.cc

 // Copyright (c) 2012 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/browser/histogram_synchronizer.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_delta_serialization.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 142 matching lines @@
 };
 
 // static
 base::LazyInstance
     <HistogramSynchronizer::RequestContext::RequestContextMap>::Leaky
         HistogramSynchronizer::RequestContext::outstanding_requests_ =
             LAZY_INSTANCE_INITIALIZER;
 
 HistogramSynchronizer::HistogramSynchronizer()
     : lock_(),
-      callback_thread_(NULL),
       last_used_sequence_number_(kNeverUsableSequenceNumber),
       async_sequence_number_(kNeverUsableSequenceNumber) {
   HistogramController::GetInstance()->Register(this);
 }
 
 HistogramSynchronizer::~HistogramSynchronizer() {
   RequestContext::OnShutdown();
 
   // Just in case we have any pending tasks, clear them out.
-  SetCallbackTaskAndThread(NULL, base::Closure());
+  SetTaskRunnerAndCallback(nullptr, base::Closure());
 }
 
 HistogramSynchronizer* HistogramSynchronizer::GetInstance() {
   return base::Singleton<
       HistogramSynchronizer,
       base::LeakySingletonTraits<HistogramSynchronizer>>::get();
 }
 
 // static
 void HistogramSynchronizer::FetchHistograms() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HistogramSynchronizer::FetchHistograms));
     return;
   }
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::GetInstance();
   if (current_synchronizer == NULL)
     return;
 
   current_synchronizer->RegisterAndNotifyAllProcesses(
       HistogramSynchronizer::UNKNOWN,
       base::TimeDelta::FromMinutes(1));
 }
 
-void FetchHistogramsAsynchronously(base::MessageLoop* callback_thread,
+void FetchHistogramsAsynchronously(scoped_refptr<base::TaskRunner> task_runner,
                                    const base::Closure& callback,
                                    base::TimeDelta wait_time) {
-  HistogramSynchronizer::FetchHistogramsAsynchronously(
-      callback_thread, callback, wait_time);
+  HistogramSynchronizer::FetchHistogramsAsynchronously(std::move(task_runner),
+                                                       callback, wait_time);
 }
 
 // static
 void HistogramSynchronizer::FetchHistogramsAsynchronously(
-    base::MessageLoop* callback_thread,
+    scoped_refptr<base::TaskRunner> task_runner,
     const base::Closure& callback,
     base::TimeDelta wait_time) {
-  DCHECK(callback_thread != NULL);
+  DCHECK(task_runner);
   DCHECK(!callback.is_null());
 
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::GetInstance();
-  current_synchronizer->SetCallbackTaskAndThread(
-      callback_thread, callback);
+  current_synchronizer->SetTaskRunnerAndCallback(std::move(task_runner),
+                                                 callback);
 
   current_synchronizer->RegisterAndNotifyAllProcesses(
       HistogramSynchronizer::ASYNC_HISTOGRAMS, wait_time);
 }
 
 void HistogramSynchronizer::RegisterAndNotifyAllProcesses(
     ProcessHistogramRequester requester,
     base::TimeDelta wait_time) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 40 matching lines @@
 
   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;
 
   // Delete request if we have heard back from all child processes.
   request->DecrementProcessesPending();
   request->DeleteIfAllDone();
 }
 
-void HistogramSynchronizer::SetCallbackTaskAndThread(
-    base::MessageLoop* callback_thread,
+void HistogramSynchronizer::SetTaskRunnerAndCallback(
+    scoped_refptr<base::TaskRunner> task_runner,
     const base::Closure& callback) {
   base::Closure old_callback;
-  base::MessageLoop* old_thread = NULL;
+  scoped_refptr<base::TaskRunner> old_task_runner;
   {
     base::AutoLock auto_lock(lock_);
     old_callback = callback_;
     callback_ = callback;
-    old_thread = callback_thread_;
-    callback_thread_ = callback_thread;
+    old_task_runner = std::move(callback_task_runner_);
+    callback_task_runner_ = std::move(task_runner);
     // Prevent premature calling of our new callbacks.
     async_sequence_number_ = kNeverUsableSequenceNumber;
   }
   // Just in case there was a task pending....
-  InternalPostTask(old_thread, old_callback);
+  InternalPostTask(std::move(old_task_runner), old_callback);
 }
 
 void HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback(
     int sequence_number) {
   base::Closure callback;
-  base::MessageLoop* thread = NULL;
+  scoped_refptr<base::TaskRunner> task_runner;
   {
     base::AutoLock lock(lock_);
     if (sequence_number != async_sequence_number_)
       return;
     callback = callback_;
-    thread = callback_thread_;
+    task_runner = std::move(callback_task_runner_);
     callback_.Reset();
-    callback_thread_ = NULL;
   }
-  InternalPostTask(thread, callback);
+  InternalPostTask(std::move(task_runner), callback);
 }
 
-void HistogramSynchronizer::InternalPostTask(base::MessageLoop* thread,
-                                             const base::Closure& callback) {
-  if (callback.is_null() || !thread)
+void HistogramSynchronizer::InternalPostTask(
+    scoped_refptr<base::TaskRunner> task_runner,
+    const base::Closure& callback) {
+  if (callback.is_null() || !task_runner)
     return;
-  thread->task_runner()->PostTask(FROM_HERE, callback);
+  task_runner->PostTask(FROM_HERE, callback);
 }
 
 int HistogramSynchronizer::GetNextAvailableSequenceNumber(
     ProcessHistogramRequester requester) {
   base::AutoLock auto_lock(lock_);
   ++last_used_sequence_number_;
   // Watch out for wrapping to a negative number.
   if (last_used_sequence_number_ < 0) {
     // Bypass the reserved number, which is used when a renderer spontaneously
     // decides to send some histogram data.
     last_used_sequence_number_ =
         kHistogramSynchronizerReservedSequenceNumber + 1;
   }
   DCHECK_NE(last_used_sequence_number_,
             kHistogramSynchronizerReservedSequenceNumber);
   if (requester == ASYNC_HISTOGRAMS)
     async_sequence_number_ = last_used_sequence_number_;
   return last_used_sequence_number_;
 }
 
 }  // namespace content