Make SpeechRecognition per RenderFrame instead of per RenderView.

content/renderer/speech_recognition_dispatcher.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 "content/renderer/speech_recognition_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/speech_recognition_messages.h"
-#include "content/renderer/render_view_impl.h"
+#include "content/renderer/render_frame_impl.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebSpeechGrammar.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognitionParams.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognitionResult.h"
 #include "third_party/WebKit/public/web/WebSpeechRecognizerClient.h"
 
 #if defined(ENABLE_WEBRTC)
 #include "content/renderer/media/speech_recognition_audio_sink.h"
 #endif
 
 using blink::WebVector;
 using blink::WebString;
 using blink::WebSpeechGrammar;
 using blink::WebSpeechRecognitionHandle;
 using blink::WebSpeechRecognitionResult;
 using blink::WebSpeechRecognitionParams;
 using blink::WebSpeechRecognizerClient;
 
 namespace content {
 
 SpeechRecognitionDispatcher::SpeechRecognitionDispatcher(
-    RenderViewImpl* render_view)
-    : RenderViewObserver(render_view),
+    RenderFrame* render_frame)
+    : RenderFrameObserver(render_frame),
       recognizer_client_(NULL),
       next_id_(1) {}
 
 SpeechRecognitionDispatcher::~SpeechRecognitionDispatcher() {}
 
-void SpeechRecognitionDispatcher::AbortAllRecognitions() {
-  ResetAudioSink();
-  Send(new SpeechRecognitionHostMsg_AbortAllRequests(
-      routing_id()));
-}
-
 bool SpeechRecognitionDispatcher::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpeechRecognitionDispatcher, message)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_Started, OnRecognitionStarted)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_AudioStarted, OnAudioStarted)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_SoundStarted, OnSoundStarted)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_SoundEnded, OnSoundEnded)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_AudioEnded, OnAudioEnded)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_ErrorOccurred, OnErrorOccurred)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_Ended, OnRecognitionEnded)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_ResultRetrieved,
                         OnResultsRetrieved)
     IPC_MESSAGE_HANDLER(SpeechRecognitionMsg_AudioReceiverReady,
                         OnAudioReceiverReady)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void SpeechRecognitionDispatcher::WasHidden() {
+#if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
+  ResetAudioSink();
+  Send(new SpeechRecognitionHostMsg_AbortAllRequests(routing_id()));
+#endif
+}
+
 void SpeechRecognitionDispatcher::start(
     const WebSpeechRecognitionHandle& handle,
     const WebSpeechRecognitionParams& params,
     WebSpeechRecognizerClient* recognizer_client) {
   DCHECK(!recognizer_client_ || recognizer_client_ == recognizer_client);
   recognizer_client_ = recognizer_client;
 
 #if defined(ENABLE_WEBRTC)
   const blink::WebMediaStreamTrack track = params.audioTrack();
   if (!track.isNull()) {
@@ skipping 21 matching lines @@
   for (size_t i = 0; i < params.grammars().size(); ++i) {
     const WebSpeechGrammar& grammar = params.grammars()[i];
     msg_params.grammars.push_back(
         SpeechRecognitionGrammar(grammar.src().spec(), grammar.weight()));
   }
   msg_params.language = base::UTF16ToUTF8(params.language());
   msg_params.max_hypotheses = static_cast<uint32>(params.maxAlternatives());
   msg_params.continuous = params.continuous();
   msg_params.interim_results = params.interimResults();
   msg_params.origin_url = params.origin().toString().utf8();
-  msg_params.render_view_id = routing_id();
   msg_params.request_id = GetOrCreateIDForHandle(handle);
 #if defined(ENABLE_WEBRTC)
   // Fall back to default input when the track is not allowed.
   msg_params.using_audio_track = !audio_track_.isNull();
 #else
   msg_params.using_audio_track = false;
 #endif
+  msg_params.render_frame_id = routing_id();
   // The handle mapping will be removed in |OnRecognitionEnd|.
   Send(new SpeechRecognitionHostMsg_StartRequest(msg_params));
 }
 
 void SpeechRecognitionDispatcher::stop(
     const WebSpeechRecognitionHandle& handle,
     WebSpeechRecognizerClient* recognizer_client) {
   ResetAudioSink();
   // Ignore a |stop| issued without a matching |start|.
   if (recognizer_client_ != recognizer_client || !HandleExists(handle))
@@ skipping 182 matching lines @@
 }
 
 const WebSpeechRecognitionHandle& SpeechRecognitionDispatcher::GetHandleFromID(
     int request_id) {
   HandleMap::iterator iter = handle_map_.find(request_id);
   DCHECK(iter != handle_map_.end());
   return iter->second;
 }
 
 }  // namespace content