base::Bind() conversion for MetricsService.

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2011 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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 246 matching lines @@
   // load.
   int instances;
 
   ChildProcessInfo::ProcessType process_type;
 };
 
 // Handles asynchronous fetching of memory details.
 // Will run the provided task after finished.
 class MetricsMemoryDetails : public MemoryDetails {
  public:
-  explicit MetricsMemoryDetails(Task* completion) : completion_(completion) {}
+  explicit MetricsMemoryDetails(const base::Closure& callback)
+      : callback_(callback) {}
 
   virtual void OnDetailsAvailable() {
-    MessageLoop::current()->PostTask(FROM_HERE, completion_);
+    MessageLoop::current()->PostTask(FROM_HERE, callback_);
   }
 
  private:
   ~MetricsMemoryDetails() {}
 
-  Task* completion_;
+  base::Closure callback_;
   DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
 };
 
 // static
 void MetricsService::RegisterPrefs(PrefService* local_state) {
   DCHECK(IsSingleThreaded());
   local_state->RegisterStringPref(prefs::kMetricsClientID, "");
   local_state->RegisterInt64Pref(prefs::kMetricsClientIDTimestamp, 0);
   local_state->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   local_state->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
@@ skipping 71 matching lines @@
 }
 
 MetricsService::MetricsService()
     : recording_active_(false),
       reporting_active_(false),
       state_(INITIALIZED),
       current_fetch_(NULL),
       io_thread_(NULL),
       idle_since_last_transmission_(false),
       next_window_id_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(log_sender_factory_(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(state_saver_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(log_sender_weak_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(state_saver_weak_factory_(this)),
       waiting_for_asynchronus_reporting_step_(false) {
   DCHECK(IsSingleThreaded());
   InitializeMetricsState();
 
   base::Closure callback = base::Bind(&MetricsService::StartScheduledUpload,
                                       base::Unretained(this));
   scheduler_.reset(new MetricsReportingScheduler(callback));
   log_manager_.set_log_serializer(new MetricsLogSerializer());
   log_manager_.set_max_ongoing_log_store_size(kUploadLogAvoidRetransmitSize);
 }
@@ skipping 373 matching lines @@
 }
 
 std::string MetricsService::GenerateClientID() {
   return guid::GenerateGUID();
 }
 
 //------------------------------------------------------------------------------
 // State save methods
 
 void MetricsService::ScheduleNextStateSave() {
-  state_saver_factory_.RevokeAll();
+  state_saver_weak_factory_.InvalidateWeakPtrs();
 
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      state_saver_factory_.NewRunnableMethod(&MetricsService::SaveLocalState),
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&MetricsService::SaveLocalState,
+                 state_saver_weak_factory_.GetWeakPtr()),
       kSaveStateInterval * 1000);
 }
 
 void MetricsService::SaveLocalState() {
   PrefService* pref = g_browser_process->local_state();
   if (!pref) {
     NOTREACHED();
     return;
   }
 
@@ skipping 90 matching lines @@
   // If reporting has been turned off, the scheduler doesn't need to run.
   if (!reporting_active() || !recording_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   DCHECK(!waiting_for_asynchronus_reporting_step_);
   waiting_for_asynchronus_reporting_step_ = true;
 
-  Task* task = log_sender_factory_.
-      NewRunnableMethod(&MetricsService::OnMemoryDetailCollectionDone);
+  base::Closure callback =
+      base::Bind(&MetricsService::OnMemoryDetailCollectionDone,
+                 log_sender_weak_factory_.GetWeakPtr());
 
-  scoped_refptr<MetricsMemoryDetails> details(new MetricsMemoryDetails(task));
+  scoped_refptr<MetricsMemoryDetails> details(
+      new MetricsMemoryDetails(callback));
   details->StartFetch();
 
   // Collect WebCore cache information to put into a histogram.
   for (content::RenderProcessHost::iterator i(
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     i.GetCurrentValue()->Send(new ChromeViewMsg_GetCacheResourceStats());
 }
 
 void MetricsService::OnMemoryDetailCollectionDone() {
   DCHECK(IsSingleThreaded());
   // This function should only be called as the callback from an ansynchronous
   // step.
   DCHECK(waiting_for_asynchronus_reporting_step_);
 
   // Right before the UMA transmission gets started, there's one more thing we'd
   // like to record: the histogram of memory usage, so we spawn a task to
   // collect the memory details and when that task is finished, it will call
   // OnMemoryDetailCollectionDone, which will call HistogramSynchronization to
   // collect histograms from all renderers and then we will call
   // OnHistogramSynchronizationDone to continue processing.
 
   // Create a callback_task for OnHistogramSynchronizationDone.
-  Task* callback_task = log_sender_factory_.NewRunnableMethod(
-      &MetricsService::OnHistogramSynchronizationDone);
+  base::Closure callback = base::Bind(
+      &MetricsService::OnHistogramSynchronizationDone,
+      log_sender_weak_factory_.GetWeakPtr());
 
   base::StatisticsRecorder::CollectHistogramStats("Browser");
 
   // Set up the callback to task to call after we receive histograms from all
   // renderer processes. Wait time specifies how long to wait before absolutely
   // calling us back on the task.
   HistogramSynchronizer::FetchRendererHistogramsAsynchronously(
-      MessageLoop::current(), callback_task,
+      MessageLoop::current(), callback,
       kMaxHistogramGatheringWaitDuration);
 }
 
 void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
 
   // If somehow there is a fetch in progress, we return and hope things work
   // out. The scheduler isn't informed since if this happens, the scheduler
   // will get a response from the upload.
   DCHECK(!current_fetch_.get());
@@ skipping 623 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }