Introduces UMA for app-list voice search.

chrome/browser/ui/app_list/start_page_service.cc

 // Copyright 2013 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 "chrome/browser/ui/app_list/start_page_service.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
+#include "base/metrics/user_metrics.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/media/media_stream_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/recommended_apps.h"
 #include "chrome/browser/ui/app_list/start_page_observer.h"
 #include "chrome/browser/ui/app_list/start_page_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "extensions/common/extension.h"
 #include "ui/app_list/app_list_switches.h"
 
+using base::RecordAction;
+using base::UserMetricsAction;
+
 namespace app_list {
 
+namespace {
+
+bool InSpeechRecognition(SpeechRecognitionState state) {
+  return state == SPEECH_RECOGNITION_RECOGNIZING ||
+      state == SPEECH_RECOGNITION_IN_SPEECH;
+}
+
+}
+
 class StartPageService::ProfileDestroyObserver
     : public content::NotificationObserver {
  public:
   explicit ProfileDestroyObserver(StartPageService* service)
       : service_(service) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::Source<Profile>(service_->profile()));
   }
   virtual ~ProfileDestroyObserver() {}
@@ skipping 34 matching lines @@
 
 // static
 StartPageService* StartPageService::Get(Profile* profile) {
   return StartPageServiceFactory::GetForProfile(profile);
 }
 
 StartPageService::StartPageService(Profile* profile)
     : profile_(profile),
       profile_destroy_observer_(new ProfileDestroyObserver(this)),
       recommended_apps_(new RecommendedApps(profile)),
-      state_(app_list::SPEECH_RECOGNITION_OFF) {
+      state_(app_list::SPEECH_RECOGNITION_OFF),
+      speech_button_toggled_manually_(false),
+      speech_result_obtained_(false) {
 #if defined(OS_CHROMEOS)
   // Updates the default state to hotword listening, because this is
   // the default behavior. This will be updated when the page is loaded and
   // the nacl module is loaded.
   if (app_list::switches::IsVoiceSearchEnabled())
     state_ = app_list::SPEECH_RECOGNITION_HOTWORD_LISTENING;
 #endif
 
   contents_.reset(content::WebContents::Create(
       content::WebContents::CreateParams(profile_)));
@@ skipping 18 matching lines @@
 
 void StartPageService::AddObserver(StartPageObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void StartPageService::RemoveObserver(StartPageObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void StartPageService::ToggleSpeechRecognition() {
+  speech_button_toggled_manually_ = true;
   contents_->GetWebUI()->CallJavascriptFunction(
       "appList.startPage.toggleSpeechRecognition");
 }
 
 content::WebContents* StartPageService::GetStartPageContents() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       ::switches::kShowAppListStartPage) ? contents_.get() : NULL;
 }
 
 content::WebContents* StartPageService::GetSpeechRecognitionContents() {
   return app_list::switches::IsVoiceSearchEnabled() ? contents_.get() : NULL;
 }
 
 void StartPageService::OnSpeechResult(
     const base::string16& query, bool is_final) {
+  if (is_final) {
+    speech_result_obtained_ = true;
+    RecordAction(UserMetricsAction("AppList_SearchedBySpeech"));
+  }
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechResult(query, is_final));
 }
 
 void StartPageService::OnSpeechSoundLevelChanged(int16 level) {
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechSoundLevelChanged(level));
 }
 
 void StartPageService::OnSpeechRecognitionStateChanged(
     SpeechRecognitionState new_state) {
+  if (!InSpeechRecognition(state_) && InSpeechRecognition(new_state)) {
+    if (!speech_button_toggled_manually_ &&
+        state_ == SPEECH_RECOGNITION_HOTWORD_LISTENING) {
+      RecordAction(UserMetricsAction("AppList_HotwordRecognized"));
+    } else {
+      RecordAction(UserMetricsAction("AppList_VoiceSearchStartedManually"));
+    }
+  } else if (InSpeechRecognition(state_) && !InSpeechRecognition(new_state) &&
+             !speech_result_obtained_) {
+    RecordAction(UserMetricsAction("AppList_VoiceSearchCanceled"));
+  }
+  speech_button_toggled_manually_ = false;
+  speech_result_obtained_ = false;
   state_ = new_state;
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechRecognitionStateChanged(new_state));
 }
 
 void StartPageService::Shutdown() {
   contents_.reset();
 }
 
 }  // namespace app_list