Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/speech/google_streaming_remote_engine.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/browser/speech/google_streaming_remote_engine.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 309 matching lines @@
   downstream_args.push_back(
       "key=" + net::EscapeQueryParamValue(GetAPIKey(), true));
   downstream_args.push_back("pair=" + request_key);
   downstream_args.push_back("output=pb");
   GURL downstream_url(std::string(kWebServiceBaseUrl) +
                       std::string(kDownstreamUrl) +
                       JoinString(downstream_args, '&'));
 
   downstream_fetcher_.reset(URLFetcher::Create(
       kDownstreamUrlFetcherIdForTests, downstream_url, URLFetcher::GET, this));
-  downstream_fetcher_->SetRequestContext(url_context_);
+  downstream_fetcher_->SetRequestContext(url_context_.get());
   downstream_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                                     net::LOAD_DO_NOT_SEND_COOKIES |
                                     net::LOAD_DO_NOT_SEND_AUTH_DATA);
   downstream_fetcher_->Start();
 
   // Setup upstream fetcher.
   // TODO(hans): Support for user-selected grammars.
   std::vector<std::string> upstream_args;
   upstream_args.push_back("key=" +
       net::EscapeQueryParamValue(GetAPIKey(), true));
@@ skipping 19 matching lines @@
   if (config_.interim_results)
     upstream_args.push_back("interim");
 
   GURL upstream_url(std::string(kWebServiceBaseUrl) +
                     std::string(kUpstreamUrl) +
                     JoinString(upstream_args, '&'));
 
   upstream_fetcher_.reset(URLFetcher::Create(
       kUpstreamUrlFetcherIdForTests, upstream_url, URLFetcher::POST, this));
   upstream_fetcher_->SetChunkedUpload(encoder_->mime_type());
-  upstream_fetcher_->SetRequestContext(url_context_);
+  upstream_fetcher_->SetRequestContext(url_context_.get());
   upstream_fetcher_->SetReferrer(config_.origin_url);
   upstream_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                                   net::LOAD_DO_NOT_SEND_COOKIES |
                                   net::LOAD_DO_NOT_SEND_AUTH_DATA);
   upstream_fetcher_->Start();
   previous_response_length_ = 0;
   return STATE_BOTH_STREAMS_CONNECTED;
 }
 
 GoogleStreamingRemoteEngine::FSMState
 GoogleStreamingRemoteEngine::TransmitAudioUpstream(
     const FSMEventArgs& event_args) {
   DCHECK(upstream_fetcher_.get());
   DCHECK(event_args.audio_data.get());
-  const AudioChunk& audio = *(event_args.audio_data);
+  const AudioChunk& audio = *(event_args.audio_data.get());
 
   DCHECK_EQ(audio.bytes_per_sample(), config_.audio_num_bits_per_sample / 8);
   encoder_->Encode(audio);
   scoped_refptr<AudioChunk> encoded_data(encoder_->GetEncodedDataAndClear());
   upstream_fetcher_->AppendChunkToUpload(encoded_data->AsString(), false);
   return state_;
 }
 
 GoogleStreamingRemoteEngine::FSMState
 GoogleStreamingRemoteEngine::ProcessDownstreamResponse(
@@ skipping 91 matching lines @@
   DVLOG(1) <<  "Closing upstream.";
 
   // The encoder requires a non-empty final buffer. So we encode a packet
   // of silence in case encoder had no data already.
   std::vector<short> samples(
       config_.audio_sample_rate * kAudioPacketIntervalMs / 1000);
   scoped_refptr<AudioChunk> dummy_chunk =
       new AudioChunk(reinterpret_cast<uint8*>(&samples[0]),
                      samples.size() * sizeof(short),
                      encoder_->bits_per_sample() / 8);
-  encoder_->Encode(*dummy_chunk);
+  encoder_->Encode(*dummy_chunk.get());
   encoder_->Flush();
   scoped_refptr<AudioChunk> encoded_dummy_data =
       encoder_->GetEncodedDataAndClear();
   DCHECK(!encoded_dummy_data->IsEmpty());
   encoder_.reset();
 
   upstream_fetcher_->AppendChunkToUpload(encoded_dummy_data->AsString(), true);
   got_last_definitive_result_ = false;
   return STATE_WAITING_DOWNSTREAM_RESULTS;
 }
@@ skipping 39 matching lines @@
 
 GoogleStreamingRemoteEngine::FSMState
 GoogleStreamingRemoteEngine::NotFeasible(const FSMEventArgs& event_args) {
   NOTREACHED() << "Unfeasible event " << event_args.event
                << " in state " << state_;
   return state_;
 }
 
 std::string GoogleStreamingRemoteEngine::GetAcceptedLanguages() const {
   std::string langs = config_.language;
-  if (langs.empty() && url_context_) {
+  if (langs.empty() && url_context_.get()) {
     // If no language is provided then we use the first from the accepted
     // language list. If this list is empty then it defaults to "en-US".
     // Example of the contents of this list: "es,en-GB;q=0.8", ""
     net::URLRequestContext* request_context =
         url_context_->GetURLRequestContext();
     DCHECK(request_context);
     // TODO(pauljensen): GoogleStreamingRemoteEngine should be constructed with
     // a reference to the HttpUserAgentSettings rather than accessing the
     // accept language through the URLRequestContext.
     std::string accepted_language_list = request_context->GetAcceptLanguage();
@@ skipping 19 matching lines @@
 }
 
 GoogleStreamingRemoteEngine::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value) {
 }
 
 GoogleStreamingRemoteEngine::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content