Moving tray icon and notification balloon for background speech recognition sessions to ChromeSpeec…

chrome/browser/speech/speech_input_extension_manager.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.
 
 #include "chrome/browser/speech/speech_input_extension_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
+#include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
-#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/browser/speech_recognition_session_config.h"
 #include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 using content::SpeechRecognitionHypothesis;
 using content::SpeechRecognitionManager;
@@ skipping 54 matching lines @@
 
  private:
   friend struct DefaultSingletonTraits<Factory>;
 
   Factory();
   virtual ~Factory();
 
   // ProfileKeyedServiceFactory methods:
   virtual ProfileKeyedService* BuildServiceInstanceFor(
       Profile* profile) const OVERRIDE;
-  virtual void RegisterUserPrefs(PrefService* prefs) OVERRIDE;
   virtual bool ServiceRedirectedInIncognito() OVERRIDE { return false; }
   virtual bool ServiceIsNULLWhileTesting() OVERRIDE { return true; }
   virtual bool ServiceIsCreatedWithProfile() OVERRIDE { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
 void SpeechInputExtensionManager::Factory::Initialize() {
   GetInstance();
 }
@@ skipping 19 matching lines @@
 }
 
 ProfileKeyedService*
     SpeechInputExtensionManager::Factory::BuildServiceInstanceFor(
     Profile* profile) const {
   scoped_refptr<SpeechInputExtensionManager> manager(
       new SpeechInputExtensionManager(profile));
   return new SpeechInputExtensionManagerWrapper(manager);
 }
 
-void SpeechInputExtensionManager::Factory::RegisterUserPrefs(
-    PrefService* prefs) {
-  prefs->RegisterBooleanPref(prefs::kSpeechInputTrayNotificationShown,
-                             false,
-                             PrefService::UNSYNCABLE_PREF);
-}
-
 SpeechInputExtensionInterface::SpeechInputExtensionInterface() {
 }
 
 SpeechInputExtensionInterface::~SpeechInputExtensionInterface() {
 }
 
 SpeechInputExtensionManager::SpeechInputExtensionManager(Profile* profile)
     : profile_(profile),
       state_(kIdle),
       registrar_(new content::NotificationRegistrar),
@@ skipping 79 matching lines @@
   VLOG(1) << "Extension unloaded. Requesting to enforce stop...";
   if (extension_id_in_use_ == extension_id) {
     if (state_ != kIdle) {
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
           base::Bind(&SpeechInputExtensionManager::ForceStopOnIOThread, this));
     }
   }
 }
 
 void SpeechInputExtensionManager::SetSpeechInputExtensionInterface(
-    SpeechInputExtensionInterface* interface) {
-  speech_interface_ = interface;
+    SpeechInputExtensionInterface* speech_interface) {
+  speech_interface_ = speech_interface;
 }
 
 SpeechInputExtensionInterface*
     SpeechInputExtensionManager::GetSpeechInputExtensionInterface() {
   return speech_interface_ ? speech_interface_ : this;
 }
 
 void SpeechInputExtensionManager::ResetToIdleState() {
   VLOG(1) << "State changed to idle. Deassociating any extensions.";
   state_ = kIdle;
   extension_id_in_use_.clear();
 }
 
+int SpeechInputExtensionManager::GetRenderProcessIDForExtension(
+    const std::string& extension_id) const {
+  ExtensionProcessManager* epm =
+      ExtensionSystem::Get(profile_)->process_manager();
+  DCHECK(epm);
+  ExtensionHost* eh = epm->GetBackgroundHostForExtension(extension_id);
+  DCHECK(eh);
+  content::RenderProcessHost* rph = eh->render_process_host();
+  DCHECK(rph);
+  return rph->GetID();
+}
+
 void SpeechInputExtensionManager::OnRecognitionResult(
     int session_id,
     const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(session_id, speech_recognition_session_id_);
 
   // Stopping will start the disassociation with the extension.
   // Make a copy to report the results to the proper one.
   std::string extension_id = extension_id_in_use_;
   ForceStopOnIOThread();
@@ skipping 65 matching lines @@
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   DCHECK_EQ(state_, kStarting);
   VLOG(1) << "State changed to recording";
   state_ = kRecording;
 
   DCHECK(profile_);
-  profile_->GetPrefs()->SetBoolean(
-      prefs::kSpeechInputTrayNotificationShown, true);
 
   VLOG(1) << "Sending start notification";
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_RECORDING_STARTED,
       content::Source<Profile>(profile_),
       content::Details<std::string>(&extension_id_in_use_));
 }
 
 void SpeechInputExtensionManager::OnRecognitionError(
     int session_id, const content::SpeechRecognitionError& error) {
@@ skipping 175 matching lines @@
       *error = kErrorInvalidOperation;
       return false;
 
     default:
       NOTREACHED();
   }
 
   const extensions::Extension* extension = profile_->GetExtensionService()->
       GetExtensionById(extension_id, true);
   DCHECK(extension);
-  const string16& extension_name = UTF8ToUTF16(extension->name());
+  const std::string& extension_name = extension->name();
 
   extension_id_in_use_ = extension_id;
   VLOG(1) << "State changed to starting";
   state_ = kStarting;
 
-  // Checks if the security notification balloon has been already shown (only
-  // once for a profile). It is reset on DidStartReceivingAudioOnUIThread.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
       profile_->GetRequestContext();
-  const bool show_notification = !profile_->GetPrefs()->GetBoolean(
-       prefs::kSpeechInputTrayNotificationShown);
+
+  const int render_process_id = GetRenderProcessIDForExtension(extension_id);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::StartOnIOThread, this,
                  url_request_context_getter, extension_name, language, grammar,
-                 filter_profanities, show_notification));
+                 filter_profanities, render_process_id));
   return true;
 }
 
 void SpeechInputExtensionManager::StartOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> context_getter,
-    const string16& extension_name,
+    const std::string& extension_name,
     const std::string& language,
     const std::string& grammar,
     bool filter_profanities,
-    bool show_notification) {
+    int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   VLOG(1) << "Requesting start (IO thread)";
 
   // Everything put inside the lock to ensure the validity of context_getter,
   // guaranteed while not in the shutdown state. Any ongoing or recognition
   // request will be requested to be aborted when entering the shutdown state.
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
@@ skipping 17 matching lines @@
         std::string(kErrorRecordingDeviceInUse), false));
     return;
   }
 
   GetSpeechInputExtensionInterface()->StartRecording(this,
                                                      context_getter,
                                                      extension_name,
                                                      language,
                                                      grammar,
                                                      filter_profanities,
-                                                     show_notification);
+                                                     render_process_id);
 }
 
 bool SpeechInputExtensionManager::HasAudioInputDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return SpeechRecognitionManager::GetInstance()->HasAudioInputDevices();
 }
 
 bool SpeechInputExtensionManager::IsCapturingAudio() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return SpeechRecognitionManager::GetInstance()->IsCapturingAudio();
@@ skipping 23 matching lines @@
 void SpeechInputExtensionManager::IsRecordingOnUIThread(
     const IsRecordingCallback& callback,
     bool result) {
   BrowserThread::CurrentlyOn(BrowserThread::UI);
   callback.Run(result);
 }
 
 void SpeechInputExtensionManager::StartRecording(
     content::SpeechRecognitionEventListener* listener,
     net::URLRequestContextGetter* context_getter,
-    const string16& extension_name,
+    const std::string& extension_name,
     const std::string& language,
     const std::string& grammar,
     bool filter_profanities,
-    bool show_notification) {
+    int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   content::SpeechRecognitionSessionContext context;
   context.requested_by_page_element = false;
-  context.is_first_request_for_context = show_notification;
+  context.render_process_id = render_process_id;
   context.context_name = extension_name;
 
   content::SpeechRecognitionSessionConfig config;
   // config.is_one_shot = true; // TODO(primiano) Uncomment when CL2.0 lands.
   config.language = language;
   config.grammars.push_back(content::SpeechRecognitionGrammar(grammar));
   config.initial_context = context;
   config.url_request_context_getter = context_getter;
   config.filter_profanities = filter_profanities;
   config.event_listener = listener;
@@ skipping 95 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_RECORDING_STOPPED,
       // Guarded by the state_ == kShutdown check.
       content::Source<Profile>(profile_),
       content::Details<std::string>(&extension_id));
 }
 
 void SpeechInputExtensionManager::OnAudioLevelsChange(int session_id,
                                                       float volume,
                                                       float noise_volume) {}