Remove unused memory usage collection in 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 151 matching lines @@
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/load_notification_details.h"
-#include "chrome/browser/memory_details.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/guid.h"
 #include "chrome/common/notification_service.h"
@@ skipping 126 matching lines @@
   int process_crashes;
 
   // The number of instances of this child process that have been created.
   // An instance is a DOM object rendered by this child process during a page
   // 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) {}
-
-  virtual void OnDetailsAvailable() {
-    MessageLoop::current()->PostTask(FROM_HERE, completion_);
-  }
-
- private:
-  ~MetricsMemoryDetails() {}
-
-  Task* completion_;
-  DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
-};
-
 class MetricsService::InitTaskComplete : public Task {
  public:
   explicit InitTaskComplete(
       const std::string& hardware_class,
       const std::vector<webkit::npapi::WebPluginInfo>& plugins)
       : hardware_class_(hardware_class), plugins_(plugins) {}
 
   virtual void Run() {
     g_browser_process->metrics_service()->OnInitTaskComplete(
         hardware_class_, plugins_);
@@ skipping 619 matching lines @@
   // If timer_pending is true because the fetch is waiting for a response,
   // we return for now and let the response handler start the timer.
   if (timer_pending_)
     return;
 
   // Before starting the timer, set timer_pending_ to true.
   timer_pending_ = true;
 
   // 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.
+  // collect histograms from all the renderers and when that task is finished,
+  // it will call OnHistogramSynchronizationDone to continue processing.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       log_sender_factory_.
           NewRunnableMethod(&MetricsService::LogTransmissionTimerDone),
       interlog_duration_.InMilliseconds());
 }
 
 void MetricsService::LogTransmissionTimerDone() {
-  Task* task = log_sender_factory_.
-      NewRunnableMethod(&MetricsService::OnMemoryDetailCollectionDone);
-
-  scoped_refptr<MetricsMemoryDetails> details(new MetricsMemoryDetails(task));
-  details->StartFetch();
-
-  // Collect WebCore cache information to put into a histogram.
-  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance())
-    i.GetCurrentValue()->Send(new ViewMsg_GetCacheResourceStats());
-}
-
-void MetricsService::OnMemoryDetailCollectionDone() {
   DCHECK(IsSingleThreaded());
 
   // HistogramSynchronizer will Collect histograms from all renderers and it
   // will call OnHistogramSynchronizationDone (if wait time elapses before it
   // heard from all renderers, then also it will call
   // OnHistogramSynchronizationDone).
 
   // Create a callback_task for OnHistogramSynchronizationDone.
   Task* callback_task = log_sender_factory_.NewRunnableMethod(
       &MetricsService::OnHistogramSynchronizationDone);
 
   // 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,
       kMaxHistogramGatheringWaitDuration);
+
+  // Collect WebCore cache information to put into a histogram.
+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance())
+    i.GetCurrentValue()->Send(new ViewMsg_GetCacheResourceStats());
 }
 
 void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
 
   // This function should only be called via timer, so timer_pending_
   // should be true.
   DCHECK(timer_pending_);
   timer_pending_ = false;
 
@@ skipping 912 matching lines @@
     thread_id = base::PlatformThread::CurrentId();
   return base::PlatformThread::CurrentId() == thread_id;
 }
 
 #if defined(OS_CHROMEOS)
 void MetricsService::StartExternalMetrics() {
   external_metrics_ = new chromeos::ExternalMetrics;
   external_metrics_->Start();
 }
 #endif