[Metrics] Move non-idle notifications from MetricsService to ChromeMetricsServiceClient

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 583 matching lines @@
 
 bool MetricsService::reporting_active() const {
   DCHECK(IsSingleThreaded());
   return reporting_active_;
 }
 
 // static
 void MetricsService::SetUpNotifications(
     content::NotificationRegistrar* registrar,
     content::NotificationObserver* observer) {
-  registrar->Add(observer, chrome::NOTIFICATION_BROWSER_OPENED,
-                 content::NotificationService::AllBrowserContextsAndSources());
-  registrar->Add(observer, chrome::NOTIFICATION_BROWSER_CLOSED,
-                 content::NotificationService::AllSources());
-  registrar->Add(observer, chrome::NOTIFICATION_TAB_PARENTED,
-                 content::NotificationService::AllSources());
-  registrar->Add(observer, chrome::NOTIFICATION_TAB_CLOSING,
-                 content::NotificationService::AllSources());
   registrar->Add(observer, content::NOTIFICATION_LOAD_START,
                  content::NotificationService::AllSources());
-  registrar->Add(observer, content::NOTIFICATION_LOAD_STOP,
-                 content::NotificationService::AllSources());
   registrar->Add(observer, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar->Add(observer, content::NOTIFICATION_RENDER_WIDGET_HOST_HANG,
                  content::NotificationService::AllSources());
-  registrar->Add(observer, chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
-                 content::NotificationService::AllSources());
 }
 
 void MetricsService::BrowserChildProcessHostConnected(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).process_launches++;
 }
 
 void MetricsService::BrowserChildProcessCrashed(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).process_crashes++;
   // Exclude plugin crashes from the count below because we report them via
   // a separate UMA metric.
   if (!IsPluginProcess(data.process_type))
     IncrementPrefValue(prefs::kStabilityChildProcessCrashCount);
 }
 
 void MetricsService::BrowserChildProcessInstanceCreated(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).instances++;
 }
 
 void MetricsService::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK(log_manager_.current_log());
   DCHECK(IsSingleThreaded());
 
   switch (type) {
-    case chrome::NOTIFICATION_BROWSER_OPENED:
-    case chrome::NOTIFICATION_BROWSER_CLOSED:
-    case chrome::NOTIFICATION_OMNIBOX_OPENED_URL:
-    case chrome::NOTIFICATION_TAB_PARENTED:
-    case chrome::NOTIFICATION_TAB_CLOSING:
-    case content::NOTIFICATION_LOAD_STOP:
-      // These notifications are used only to break out of idle mode.
-      break;
-
     case content::NOTIFICATION_LOAD_START: {
       content::NavigationController* controller =
           content::Source<content::NavigationController>(source).ptr();
       content::WebContents* web_contents = controller->GetWebContents();
       LogLoadStarted(web_contents);
       break;
     }
 
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost::RendererClosedDetails* process_details =
           content::Details<
               content::RenderProcessHost::RendererClosedDetails>(
                   details).ptr();
       content::RenderProcessHost* host =
           content::Source<content::RenderProcessHost>(source).ptr();
       LogRendererCrash(
           host, process_details->status, process_details->exit_code);
       break;
     }
 
     case content::NOTIFICATION_RENDER_WIDGET_HOST_HANG:
       LogRendererHang();
       break;
 
     default:
       NOTREACHED();
-      break;
   }
-
-  HandleIdleSinceLastTransmission(false);
 }
 
 void MetricsService::HandleIdleSinceLastTransmission(bool in_idle) {
   // If there wasn't a lot of action, maybe the computer was asleep, in which
   // case, the log transmissions should have stopped.  Here we start them up
   // again.
   if (!in_idle && idle_since_last_transmission_)
     StartSchedulerIfNecessary();
   idle_since_last_transmission_ = in_idle;
 }
 
+void MetricsService::OnApplicationNotIdle() {
+  if (recording_active_)
+    HandleIdleSinceLastTransmission(false);
+}
+
 void MetricsService::RecordStartOfSessionEnd() {
   LogCleanShutdown();
   RecordBooleanPrefValue(prefs::kStabilitySessionEndCompleted, false);
 }
 
 void MetricsService::RecordCompletedSessionEnd() {
   LogCleanShutdown();
   RecordBooleanPrefValue(prefs::kStabilitySessionEndCompleted, true);
 }
 
@@ skipping 499 matching lines @@
   }
 }
 
 void MetricsService::StartScheduledUpload() {
   // If we're getting no notifications, then the log won't have much in it, and
   // it's possible the computer is about to go to sleep, so don't upload and
   // stop the scheduler.
   // If recording has been turned off, the scheduler doesn't need to run.
   // If reporting is off, proceed if the initial log hasn't been created, since
   // that has to happen in order for logs to be cut and stored when persisting.
-  // TODO(stuartmorgan): Call Stop() on the schedule when reporting and/or
+  // TODO(stuartmorgan): Call Stop() on the scheduler when reporting and/or
   // recording are turned off instead of letting it fire and then aborting.
   if (idle_since_last_transmission_ ||
       !recording_active() ||
       (!reporting_active() && state_ >= SENDING_INITIAL_STABILITY_LOG)) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   // If the callback was to upload an old log, but there no longer is one,
@@ skipping 742 matching lines @@
   if (metrics_service)
     metrics_service->AddObserver(observer);
 }
 
 void MetricsServiceHelper::RemoveMetricsServiceObserver(
     MetricsServiceObserver* observer) {
   MetricsService* metrics_service = g_browser_process->metrics_service();
   if (metrics_service)
     metrics_service->RemoveObserver(observer);
 }