content: convert user action notification to observer usage

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
@@ skipping 618 matching lines @@
   if (recording_active_)
     return;
   recording_active_ = true;
 
   ForceClientIdCreation();
   child_process_logging::SetClientId(client_id_);
   if (!log_manager_.current_log())
     OpenNewLog();
 
   SetUpNotifications(&registrar_, this);
+  content::RemoveActionCallback(action_callback_);
+  action_callback_ = base::Bind(&MetricsService::OnUserAction,
+                                base::Unretained(this));
+  content::AddActionCallback(action_callback_);
 }
 
 void MetricsService::DisableRecording() {
   DCHECK(IsSingleThreaded());
 
   if (!recording_active_)
     return;
   recording_active_ = false;
 
+  content::RemoveActionCallback(action_callback_);
   registrar_.RemoveAll();
   PushPendingLogsToPersistentStorage();
   DCHECK(!log_manager_.has_staged_log());
 }
 
 bool MetricsService::recording_active() const {
   DCHECK(IsSingleThreaded());
   return recording_active_;
 }
 
 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, content::NOTIFICATION_USER_ACTION,
-                 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());
@@ skipping 12 matching lines @@
   registrar->Add(observer, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void MetricsService::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK(log_manager_.current_log());
   DCHECK(IsSingleThreaded());
 
-  if (!CanLogNotification(type, source, details))
+  if (!CanLogNotification())
     return;
 
   switch (type) {
-    case content::NOTIFICATION_USER_ACTION:
-         log_manager_.current_log()->RecordUserAction(
-             *content::Details<const char*>(details).ptr());
-      break;
-
     case chrome::NOTIFICATION_BROWSER_OPENED:
     case chrome::NOTIFICATION_BROWSER_CLOSED: {
       Browser* browser = content::Source<Browser>(source).ptr();
       LogWindowOrTabChange(type, reinterpret_cast<uintptr_t>(browser));
       break;
     }
 
     case chrome::NOTIFICATION_TAB_PARENTED: {
       content::WebContents* web_contents =
           content::Source<content::WebContents>(source).ptr();
@@ skipping 319 matching lines @@
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
 
   google_update_metrics_ = google_update_metrics;
 
   // Start the next part of the init task: fetching performance data.  This will
   // call into |FinishedReceivingProfilerData()| when the task completes.
   chrome_browser_metrics::TrackingSynchronizer::FetchProfilerDataAsynchronously(
       self_ptr_factory_.GetWeakPtr());
 }
 
+void MetricsService::OnUserAction(const std::string& action) {
+  if (!CanLogNotification())
+    return;
+
+  log_manager_.current_log()->RecordUserAction(action.c_str());
+  HandleIdleSinceLastTransmission(false);
+}
+
 void MetricsService::ReceivedProfilerData(
     const tracked_objects::ProcessDataSnapshot& process_data,
     content::ProcessType process_type) {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
 
   // Upon the first callback, create the initial log so that we can immediately
   // save the profiler data.
   if (!initial_log_.get())
     initial_log_.reset(new MetricsLog(client_id_, session_id_));
 
@@ skipping 875 matching lines @@
                             stats.process_crashes);
     plugin_dict->SetInteger(prefs::kStabilityPluginInstances,
                             stats.instances);
     plugin_dict->SetInteger(prefs::kStabilityPluginLoadingErrors,
                             stats.loading_errors);
     plugins->Append(plugin_dict);
   }
   child_process_stats_buffer_.clear();
 }
 
-bool MetricsService::CanLogNotification(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
+bool MetricsService::CanLogNotification() {
   // We simply don't log anything to UMA if there is a single incognito
   // session visible. The problem is that we always notify using the orginal
   // profile in order to simplify notification processing.
   return !chrome::IsOffTheRecordSessionActive();
 }
 
 void MetricsService::RecordBooleanPrefValue(const char* path, bool value) {
   DCHECK(IsSingleThreaded());
 
   PrefService* pref = g_browser_process->local_state();
@@ skipping 30 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;
 }