[Hotword] Add error message display back in. Add error messages for NaCl. Add metrics for errors.

chrome/browser/search/hotword_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/search/hotword_service.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
+#include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/search/hotword_service_factory.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/plugin_service.h"
+#include "content/public/common/webplugininfo.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
+#include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 // The whole file relies on the extension systems but this file is built on
 // some non-extension supported platforms and including an API header will cause
 // a compile error since it depends on header files generated by .idl.
 // TODO(mukai): clean up file dependencies and remove this clause.
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/hotword_private/hotword_private_api.h"
 #endif
 
@@ skipping 27 matching lines @@
 // This is used for UMA stats -- do not reorder or delete items; only add to
 // the end.
 enum HotwordExtensionAvailability {
   UNAVAILABLE = 0,
   AVAILABLE,
   PENDING_DOWNLOAD,
   DISABLED_EXTENSION,
   NUM_HOTWORD_EXTENSION_AVAILABILITY_METRICS
 };
 
-void RecordAvailabilityMetrics(
+// Enum describing the types of errors that can arise when determining
+// if hotwording can be used. NO_ERROR is used so it can be seen how often
+// errors arise relative to when they do not.
+// This is used for UMA stats -- do not reorder or delete items; only add to
+// the end.
+enum HotwordError {
+  NO_ERROR = 0,
+  GENERIC_ERROR,
+  NACL_ERROR,
+  MICROPHONE_ERROR,
+  NUM_HOTWORD_ERROR_METRICS
+};
+
+void RecordExtensionAvailabilityMetrics(
     ExtensionService* service,
     const extensions::Extension* extension) {
   HotwordExtensionAvailability availability_state = UNAVAILABLE;
   if (extension) {
     availability_state = AVAILABLE;
   } else if (service->pending_extension_manager() &&
              service->pending_extension_manager()->IsIdPending(
                  extension_misc::kHotwordExtensionId)) {
     availability_state = PENDING_DOWNLOAD;
   } else if (!service->IsExtensionEnabled(
       extension_misc::kHotwordExtensionId)) {
     availability_state = DISABLED_EXTENSION;
   }
   UMA_HISTOGRAM_ENUMERATION("Hotword.HotwordExtensionAvailability",
                             availability_state,
                             NUM_HOTWORD_EXTENSION_AVAILABILITY_METRICS);
 }
 
 void RecordLoggingMetrics(Profile* profile) {
   // If the user is not opted in to hotword voice search, the audio logging
   // metric is not valid so it is not recorded.
   if (!profile->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled))
     return;
 
   UMA_HISTOGRAM_BOOLEAN(
       "Hotword.HotwordAudioLogging",
       profile->GetPrefs()->GetBoolean(prefs::kHotwordAudioLoggingEnabled));
 }
 
+void RecordErrorMetrics(int error_message) {
+  HotwordError error = NO_ERROR;
+  switch (error_message) {
+    case IDS_HOTWORD_GENERIC_ERROR_MESSAGE:
+      error = GENERIC_ERROR;
+      break;
+    case IDS_HOTWORD_NACL_DISABLED_ERROR_MESSAGE:
+      error = NACL_ERROR;
+      break;
+    default:

[Jered, 2014/05/19 20:47:34]

You should probably hook up the other two errors, here, right? Otherwise they
will be reported as NO_ERROR.

[rpetterson, 2014/05/19 21:04:17]

There's only one other error right now -- the microphone. It's going to be added
as a separate CL since detecting it was more complicated. It's fine if it shows
up as NO_ERROR for now since we can just be aware of when we're looking at the
errors from (i.e., anything past some date will include the mic, before that
will not).

[Mark P, 2014/05/19 22:01:31]

This is a fine answer if you're pretty sure the new change will go in soon.  If
you're likely to have a stable release that includes this code without the
microphone error code, that could end up much more confusing, making it less
likely that people remember the changing interpretation by date.

[rpetterson, 2014/05/19 22:04:19]

It will be soon, probably this week. The CL is mostly done with one
implementation and we're just investigating if there's a better way to do it.

+      error = NO_ERROR;
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("Hotword.HotwordError",
+                            error,
+                            NUM_HOTWORD_ERROR_METRICS);
+}
+
 ExtensionService* GetExtensionService(Profile* profile) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   if (extension_system)
     return extension_system->extension_service();
   return NULL;
 }
 
@@ skipping 21 matching lines @@
 
   for (size_t i = 0; i < arraysize(kSupportedLocales); i++) {
     if (normalized_locale.compare(0, 2, kSupportedLocales[i]) == 0)
       return true;
   }
   return false;
 }
 
 HotwordService::HotwordService(Profile* profile)
     : profile_(profile),
-      client_(NULL) {
+      client_(NULL),
+      error_message_(0) {
   // This will be called during profile initialization which is a good time
   // to check the user's hotword state.
   HotwordEnabled enabled_state = UNSET;
   if (profile_->GetPrefs()->HasPrefPath(prefs::kHotwordSearchEnabled)) {
     if (profile_->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled))
       enabled_state = ENABLED;
     else
       enabled_state = DISABLED;
   } else {
     // If the preference has not been set the hotword extension should
@@ skipping 69 matching lines @@
 
 void HotwordService::ShowOptInPopup() {
   int number_shown = profile_->GetPrefs()->GetInteger(
       prefs::kHotwordOptInPopupTimesShown);
   profile_->GetPrefs()->SetInteger(prefs::kHotwordOptInPopupTimesShown,
                                    ++number_shown);
   // TODO(rlp): actually show opt in popup when linked up to extension.
 }
 
 bool HotwordService::IsServiceAvailable() {
+  error_message_ = 0;
+
+  // Determine if the extension is available.
   extensions::ExtensionSystem* system =
       extensions::ExtensionSystem::Get(profile_);
   ExtensionService* service = system->extension_service();
   // Include disabled extensions (true parameter) since it may not be enabled
   // if the user opted out.
   const extensions::Extension* extension =
       service->GetExtensionById(extension_misc::kHotwordExtensionId, true);
+  if (!extension)
+    error_message_ = IDS_HOTWORD_GENERIC_ERROR_MESSAGE;
 
-  RecordAvailabilityMetrics(service, extension);
+  RecordExtensionAvailabilityMetrics(service, extension);
   RecordLoggingMetrics(profile_);
 
-  return extension && IsHotwordAllowed();
+  // Determine if NaCl is available.
+  bool nacl_enabled = false;
+  base::FilePath path;
+  if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
+    content::WebPluginInfo info;
+    PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_).get();
+    if (content::PluginService::GetInstance()->GetPluginInfoByPath(path, &info))
+      nacl_enabled = plugin_prefs->IsPluginEnabled(info);
+  }
+  if (!nacl_enabled)
+    error_message_ = IDS_HOTWORD_NACL_DISABLED_ERROR_MESSAGE;
+
+  RecordErrorMetrics(error_message_);
+
+  return (error_message_ == 0) && IsHotwordAllowed();
 }
 
 bool HotwordService::IsHotwordAllowed() {
   std::string group = base::FieldTrialList::FindFullName(
       hotword_internal::kHotwordFieldTrialName);
   return !group.empty() &&
       group != hotword_internal::kHotwordFieldTrialDisabledGroupName &&
       DoesHotwordSupportLanguage(profile_);
 }
 
 bool HotwordService::IsOptedIntoAudioLogging() {
   // Do not opt the user in if the preference has not been set.
   return
       profile_->GetPrefs()->HasPrefPath(prefs::kHotwordAudioLoggingEnabled) &&
       profile_->GetPrefs()->GetBoolean(prefs::kHotwordAudioLoggingEnabled);
 }
 
-bool HotwordService::RetryHotwordExtension() {
-  ExtensionService* extension_service = GetExtensionService(profile_);
-  if (!extension_service)
-    return false;
-
-  extension_service->ReloadExtension(extension_misc::kHotwordExtensionId);
-  return true;
-}
-
 void HotwordService::EnableHotwordExtension(
     ExtensionService* extension_service) {
   if (extension_service)
     extension_service->EnableExtension(extension_misc::kHotwordExtensionId);
 }
 
 void HotwordService::DisableHotwordExtension(
     ExtensionService* extension_service) {
   if (extension_service) {
     extension_service->DisableExtension(
@@ skipping 34 matching lines @@
 
   DCHECK(client_ == client);
 
   client_ = NULL;
   HotwordPrivateEventService* event_service =
       BrowserContextKeyedAPIFactory<HotwordPrivateEventService>::Get(profile_);
   if (event_service)
     event_service->OnHotwordSessionStopped();
 #endif
 }