Plumb preamble log data from the hotword extension into the speech recognizer.

chrome/browser/ui/app_list/speech_recognizer.cc

 // Copyright 2014 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/ui/app_list/speech_recognizer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/ui/app_list/speech_recognizer_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/speech_recognition_event_listener.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_preamble.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/app_list/speech_ui_model_observer.h"
 
 namespace app_list {
 
 // Length of timeout to cancel recognition if there's no speech heard.
 static const int kNoSpeechTimeoutInSeconds = 5;
 
 // Invalid speech session.
 static const int kInvalidSessionId = -1;
 
 // Speech recognizer listener. This is separate from SpeechRecognizer because
 // the speech recognition engine must function from the IO thread. Because of
 // this, the lifecycle of this class must be decoupled from the lifecycle of
 // SpeechRecognizer. To avoid circular references, this class has no reference
 // to SpeechRecognizer. Instead, it has a reference to the
 // SpeechRecognizerDelegate via a weak pointer that is only ever referenced from
 // the UI thread.
 class SpeechRecognizer::EventListener
     : public base::RefCountedThreadSafe<SpeechRecognizer::EventListener>,
       public content::SpeechRecognitionEventListener {
  public:
   EventListener(const base::WeakPtr<SpeechRecognizerDelegate>& delegate,
                 net::URLRequestContextGetter* url_request_context_getter,
                 const std::string& locale);
 
-  void StartOnIOThread(const std::string& auth_scope,
-                       const std::string& auth_token);
+  void StartOnIOThread(
+      const std::string& auth_scope,
+      const std::string& auth_token,
+      const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble);
   void StopOnIOThread();
 
  private:
   friend class base::RefCountedThreadSafe<SpeechRecognizer::EventListener>;
   ~EventListener();
 
   void NotifyRecognitionStateChanged(SpeechRecognitionState new_state);
 
   void StartSpeechTimeout();
   void StopSpeechTimeout();
@@ skipping 42 matching lines @@
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 SpeechRecognizer::EventListener::~EventListener() {
   DCHECK(!speech_timeout_.IsRunning());
 }
 
 void SpeechRecognizer::EventListener::StartOnIOThread(
     const std::string& auth_scope,
-    const std::string& auth_token) {
+    const std::string& auth_token,
+    const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (session_ != kInvalidSessionId)
     StopOnIOThread();
 
   content::SpeechRecognitionSessionConfig config;
   config.language = locale_;
   config.is_legacy_api = false;
   config.continuous = true;
   config.interim_results = true;
   config.max_hypotheses = 1;
   config.filter_profanities = true;
   config.url_request_context_getter = url_request_context_getter_;
   config.event_listener = weak_factory_.GetWeakPtr();
   // kInvalidUniqueID is not a valid render process, so the speech permission
   // check allows the request through.
   config.initial_context.render_process_id =
       content::ChildProcessHost::kInvalidUniqueID;
   config.auth_scope = auth_scope;
   config.auth_token = auth_token;
+  config.preamble = preamble;
 
   auto speech_instance = content::SpeechRecognitionManager::GetInstance();
   session_ = speech_instance->CreateSession(config);
   speech_instance->StartSession(session_);
 }
 
 void SpeechRecognizer::EventListener::StopOnIOThread() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (session_ == kInvalidSessionId)
     return;
@@ skipping 121 matching lines @@
       speech_event_listener_(new EventListener(
           delegate, url_request_context_getter, locale)) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 SpeechRecognizer::~SpeechRecognizer() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   Stop();
 }
 
-void SpeechRecognizer::Start() {
+void SpeechRecognizer::Start(
+    const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::string auth_scope;
   std::string auth_token;
   delegate_->GetSpeechAuthParameters(&auth_scope, &auth_token);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SpeechRecognizer::EventListener::StartOnIOThread,
                  speech_event_listener_,
                  auth_scope,
-                 auth_token));
+                 auth_token,
+                 preamble));
 }
 
 void SpeechRecognizer::Stop() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SpeechRecognizer::EventListener::StopOnIOThread,
                  speech_event_listener_));
 }
 
 }  // namespace app_list