Remove use of default request context and fix use of speech censor flag

content/browser/speech/speech_recognizer.cc

 // Copyright (c) 2011 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/browser/speech/speech_recognizer.h"
 
 #include "base/time.h"
 #include "content/browser/browser_thread.h"
-#include "content/browser/content_browser_client.h"
-#include "content/common/content_client.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using media::AudioInputController;
 using std::string;
 
 namespace {
 
 // The following constants are related to the volume level indicator shown in
 // the UI for recorded audio.
 // Multiplier used when new volume is greater than previous level.
@@ skipping 31 matching lines @@
 const int SpeechRecognizer::kAudioPacketIntervalMs = 100;
 const ChannelLayout SpeechRecognizer::kChannelLayout = CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizer::kNoSpeechTimeoutSec = 8;
 const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
 
 SpeechRecognizer::SpeechRecognizer(Delegate* delegate,
                                    int caller_id,
                                    const std::string& language,
                                    const std::string& grammar,
+                                   net::URLRequestContextGetter* context_getter,
                                    bool censor_results,
                                    const std::string& hardware_info,
                                    const std::string& origin_url)
     : delegate_(delegate),
       caller_id_(caller_id),
       language_(language),
       grammar_(grammar),
       censor_results_(censor_results),
       hardware_info_(hardware_info),
       origin_url_(origin_url),
+      context_getter_(context_getter),
       codec_(AudioEncoder::CODEC_FLAC),
       encoder_(NULL),
       endpointer_(kAudioSampleRate),
       num_samples_recorded_(0),
       audio_level_(0.0f) {
   endpointer_.set_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond / 2);
   endpointer_.set_long_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond);
   endpointer_.set_long_speech_length(3 * base::Time::kMicrosecondsPerSecond);
@@ skipping 135 matching lines @@
   float rms;
   endpointer_.ProcessAudio(samples, num_samples, &rms);
   bool did_clip = Clipping(samples, num_samples);
   delete data;
   num_samples_recorded_ += num_samples;
 
   if (request_ == NULL) {
     // This was the first audio packet recorded, so start a request to the
     // server to send the data and inform the delegate.
     delegate_->DidStartReceivingAudio(caller_id_);
-    // Deprecated; see http://crbug.com/92366
-    net::URLRequestContextGetter* context_getter =
-        content::GetContentClient()->browser()->
-            GetDefaultRequestContextDeprecatedCrBug64339();
-    request_.reset(new SpeechRecognitionRequest(context_getter, this));
-    request_->Start(language_, grammar_, censor_results_, hardware_info_,
-                    origin_url_, encoder_->mime_type());
+    request_.reset(new SpeechRecognitionRequest(context_getter_.get(), this));
+    request_->Start(language_, grammar_, censor_results_,
+                    hardware_info_, origin_url_, encoder_->mime_type());
   }
 
   string encoded_data;
   encoder_->GetEncodedDataAndClear(&encoded_data);
   DCHECK(!encoded_data.empty());
   request_->UploadAudioChunk(encoded_data, false /* is_last_chunk */);
 
   if (endpointer_.IsEstimatingEnvironment()) {
     // Check if we have gathered enough audio for the endpointer to do
     // environment estimation and should move on to detect speech/end of speech.
@@ skipping 56 matching lines @@
 
 void SpeechRecognizer::InformErrorAndCancelRecognition(ErrorCode error) {
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
 }  // namespace speech_input