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 */);
-    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.
+  // 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(&CheckRenderViewType,
-                                     session_id,
                                      callback,
                                      context.render_process_id,
-                                     context.render_view_id));
+                                     context.render_view_id,
+                                     RequiresTrayIcon(session_id)));
 }
 
 content::SpeechRecognitionEventListener*
 ChromeSpeechRecognitionManagerDelegate::GetEventListener() {
   return this;
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowTrayIconOnUIThread(
     const std::string& context_name,
     int render_process_id,
@@ skipping 21 matching lines @@
     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(
-    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) {
+    int render_view_id,
+    bool js_api) {
   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)
+  bool ask_permission = false;
+
+  if (!render_view_host) {
+    if (!js_api) {
+      // If there is no render view, we cannot show the speech bubble, so this
+      // is not allowed.
+      allowed = false;
+      ask_permission = false;
+    } else {
+      // This happens for extensions. Manifest should be checked for permission.
       allowed = true;
+      ask_permission = false;
+    }
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, ask_permission, allowed));
+    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 it is a tab, we can show the speech input bubble or ask for
+    // permission.
+
+    allowed = true;
+    if (js_api)
+      ask_permission = true;
+  }
+
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(callback, session_id, allowed));
+                          base::Bind(callback, ask_permission, allowed));
 }
 
 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