Speech JavaScript API: Use the MediaStreamManager to ask for user permission.

chrome/browser/speech/chrome_speech_recognition_manager_delegate.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/chrome_speech_recognition_manager_delegate.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
 const char kExtensionPrefix[] = "chrome-extension://";
 
 bool RequiresBubble(int session_id) {
   return SpeechRecognitionManager::GetInstance()->
       GetSessionContext(session_id).requested_by_page_element;
 }
 
 bool RequiresTrayIcon(int session_id) {
   return !RequiresBubble(session_id);
 }
+
 }  // namespace
 
 namespace speech {
 
 // Asynchronously fetches the PC and audio hardware/driver info if
 // the user has opted into UMA. This information is sent with speech input
 // requests to the server for identifying and improving quality issues with
 // specific device configurations.
 class ChromeSpeechRecognitionManagerDelegate::OptionalRequestInfo
     : public base::RefCountedThreadSafe<OptionalRequestInfo> {
@@ skipping 390 matching lines @@
     // a long wait and disk seeks when they click on a UI element and start
     // speaking.
     optional_request_info_->Refresh();
   }
   *can_report_metrics = optional_request_info_->can_report_metrics();
   *hardware_info = optional_request_info_->value();
 }
 
 void ChromeSpeechRecognitionManagerDelegate::CheckRecognitionIsAllowed(
     int session_id,
-    base::Callback<void(int session_id, bool is_allowed)> callback) {
+    base::Callback<void(bool ask_user, bool is_allowed)> callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   const content::SpeechRecognitionSessionContext& context =
       SpeechRecognitionManager::GetInstance()->GetSessionContext(session_id);
 
   // Make sure that initiators (extensions/web pages) properly set the
   // |render_process_id| field, which is needed later to retrieve the
   // ChromeSpeechRecognitionPreferences associated to their profile.
   DCHECK_NE(context.render_process_id, 0);
 
-  // We don't need any particular check for sessions not using a bubble. In such
-  // cases, we just notify it to the manager (calling-back synchronously, since
-  // we remain in the IO thread).
   if (RequiresTrayIcon(session_id)) {
-    callback.Run(session_id, true /* is_allowed */);
+    // Check that the render view type is appropriate, and whether or not we
+    // need to request permission from the user.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&CheckRenderViewTypeForTrayIcon,
+                                       session_id,
+                                       callback,
+                                       context.render_process_id,
+                                       context.render_view_id));
+    return;
+  } else {
+    // Sessions not requiring permission need to check the renderer view type.
+    // The check must be performed in the UI thread. We defer it posting to
+    // CheckRenderViewType, which will issue the callback on our behalf.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&CheckRenderViewTypeForBubble,
+                                       session_id,
+                                       callback,
+                                       context.render_process_id,
+                                       context.render_view_id));
     return;
   }
-
-  // Sessions using bubbles, conversely, need a check on the renderer view type.
-  // The check must be performed in the UI thread. We defer it posting to
-  // CheckRenderViewType, which will issue the callback on our behalf.
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(&CheckRenderViewType,
-                                     session_id,
-                                     callback,
-                                     context.render_process_id,
-                                     context.render_view_id));
 }
 
 content::SpeechRecognitionEventListener*
 ChromeSpeechRecognitionManagerDelegate::GetEventListener() {
   return this;
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowTrayIconOnUIThread(
     const std::string& context_name,
     int render_process_id,
@@ skipping 20 matching lines @@
         context_name.substr(sizeof(kExtensionPrefix) - 1);
     const extensions::Extension* extension =
           profile->GetExtensionService()->GetExtensionById(extension_id, true);
     DCHECK(extension);
     initiator_name = UTF8ToUTF16(extension->name());
   }
 
   tray_icon_controller->Show(initiator_name, show_notification);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::CheckRenderViewType(
+void ChromeSpeechRecognitionManagerDelegate::CheckRenderViewTypeForBubble(
     int session_id,
-    base::Callback<void(int session_id, bool is_allowed)> callback,
+    base::Callback<void(bool ask_user, bool is_allowed)> callback,
     int render_process_id,
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const content::RenderViewHost* render_view_host =
       content::RenderViewHost::FromID(render_process_id, render_view_id);
   bool allowed = false;
   if (render_view_host) {
     // For host delegates other than VIEW_TYPE_TAB_CONTENTS we can't reliably
     // show a popup, including the speech input bubble. In these cases for
     // privacy reasons we don't want to start recording if the user can't be
     // properly notified. An example of this is trying to show the speech input
     // bubble within an extension popup: http://crbug.com/92083. In these
     // situations the speech input extension API should be used instead.
     WebContents* web_contents =
         WebContents::FromRenderViewHost(render_view_host);
     chrome::ViewType view_type = chrome::GetViewType(web_contents);
     if (view_type == chrome::VIEW_TYPE_TAB_CONTENTS)
       allowed = true;
   }
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(callback, session_id, allowed));
+                          base::Bind(callback, false, allowed));
+}
+
+void ChromeSpeechRecognitionManagerDelegate::CheckRenderViewTypeForTrayIcon(

[Satish, 2012/09/12 06:15:09]

there is a lot of shared code between this and the previous method. How about
passing in an additional bool to indicate if it is for the JS API or
x-webkit-speech API and merge the two methods?

[hans, 2012/09/12 09:46:58]

Done.

+    int session_id,
+    base::Callback<void(bool ask_user, bool is_allowed)> callback,
+    int render_process_id,
+    int render_view_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const content::RenderViewHost* render_view_host =
+      content::RenderViewHost::FromID(render_process_id, render_view_id);
+  if (!render_view_host) {
+    // This happens for extensions. Manifest should be checked for permission.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, false, true));
+    return;
+  }
+
+  WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
+  chrome::ViewType view_type = chrome::GetViewType(web_contents);
+  if (view_type != chrome::VIEW_TYPE_TAB_CONTENTS) {
+    // If there is no tab we don't allow, because we wouldn't be able to show an
+    // infobar.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, false, false));
+    return;
+  }
+
+  // Call back saying that we need to ask the user for permission.
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(callback, true, true));
 }
 
 SpeechRecognitionBubbleController*
 ChromeSpeechRecognitionManagerDelegate::GetBubbleController() {
   if (!bubble_controller_.get())
     bubble_controller_ = new SpeechRecognitionBubbleController(this);
   return bubble_controller_.get();
 }
 
 SpeechRecognitionTrayIconController*
 ChromeSpeechRecognitionManagerDelegate::GetTrayIconController() {
   if (!tray_icon_controller_.get())
     tray_icon_controller_ = new SpeechRecognitionTrayIconController();
   return tray_icon_controller_.get();
 }
 
 
 }  // namespace speech