Move a bunch of code in content\renderer to the content namespace.

content/renderer/speech_recognition_dispatcher.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/renderer/speech_recognition_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/speech_recognition_messages.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSpeechGrammar.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSpeechRecognitionParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSpeechRecognitionResult.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSpeechRecognizerClient.h"
 
-using content::SpeechRecognitionError;
-using content::SpeechRecognitionResult;
 using WebKit::WebVector;
 using WebKit::WebString;
 using WebKit::WebSpeechGrammar;
 using WebKit::WebSpeechRecognitionHandle;
 using WebKit::WebSpeechRecognitionResult;
 using WebKit::WebSpeechRecognitionParams;
 using WebKit::WebSpeechRecognizerClient;
 
+namespace content {
+
 SpeechRecognitionDispatcher::SpeechRecognitionDispatcher(
     RenderViewImpl* render_view)
-    : content::RenderViewObserver(render_view),
+    : RenderViewObserver(render_view),
       recognizer_client_(NULL),
       next_id_(1) {
 }
 
 SpeechRecognitionDispatcher::~SpeechRecognitionDispatcher() {
 }
 
 bool SpeechRecognitionDispatcher::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
@@ skipping 15 matching lines @@
     const WebSpeechRecognitionHandle& handle,
     const WebSpeechRecognitionParams& params,
     WebSpeechRecognizerClient* recognizer_client) {
   DCHECK(!recognizer_client_ || recognizer_client_ == recognizer_client);
   recognizer_client_ = recognizer_client;
 
   SpeechRecognitionHostMsg_StartRequest_Params msg_params;
   for (size_t i = 0; i < params.grammars().size(); ++i) {
     const WebSpeechGrammar& grammar = params.grammars()[i];
     msg_params.grammars.push_back(
-        content::SpeechRecognitionGrammar(grammar.src().spec(),
-                                          grammar.weight()));
+        SpeechRecognitionGrammar(grammar.src().spec(), grammar.weight()));
   }
   msg_params.language = UTF16ToUTF8(params.language());
   msg_params.max_hypotheses = static_cast<uint32>(params.maxAlternatives());
   msg_params.continuous = params.continuous();
   msg_params.interim_results = params.interimResults();
   msg_params.origin_url = params.origin().toString().utf8();
   msg_params.render_view_id = routing_id();
   msg_params.request_id = GetOrCreateIDForHandle(handle);
   // The handle mapping will be removed in |OnRecognitionEnd|.
   Send(new SpeechRecognitionHostMsg_StartRequest(msg_params));
@@ skipping 33 matching lines @@
 
 void SpeechRecognitionDispatcher::OnSoundEnded(int request_id) {
   recognizer_client_->didEndSound(GetHandleFromID(request_id));
 }
 
 void SpeechRecognitionDispatcher::OnAudioEnded(int request_id) {
   recognizer_client_->didEndAudio(GetHandleFromID(request_id));
 }
 
 static WebSpeechRecognizerClient::ErrorCode WebKitErrorCode(
-    content::SpeechRecognitionErrorCode e) {
+    SpeechRecognitionErrorCode e) {
   switch (e) {
-    case content::SPEECH_RECOGNITION_ERROR_NONE:
+    case SPEECH_RECOGNITION_ERROR_NONE:
       NOTREACHED();
       return WebSpeechRecognizerClient::OtherError;
-    case content::SPEECH_RECOGNITION_ERROR_ABORTED:
+    case SPEECH_RECOGNITION_ERROR_ABORTED:
       return WebSpeechRecognizerClient::AbortedError;
-    case content::SPEECH_RECOGNITION_ERROR_AUDIO:
+    case SPEECH_RECOGNITION_ERROR_AUDIO:
       return WebSpeechRecognizerClient::AudioCaptureError;
-    case content::SPEECH_RECOGNITION_ERROR_NETWORK:
+    case SPEECH_RECOGNITION_ERROR_NETWORK:
       return WebSpeechRecognizerClient::NetworkError;
-    case content::SPEECH_RECOGNITION_ERROR_NOT_ALLOWED:
+    case SPEECH_RECOGNITION_ERROR_NOT_ALLOWED:
       return WebSpeechRecognizerClient::NotAllowedError;
-    case content::SPEECH_RECOGNITION_ERROR_NO_SPEECH:
+    case SPEECH_RECOGNITION_ERROR_NO_SPEECH:
       return WebSpeechRecognizerClient::NoSpeechError;
-    case content::SPEECH_RECOGNITION_ERROR_NO_MATCH:
+    case SPEECH_RECOGNITION_ERROR_NO_MATCH:
       NOTREACHED();
       return WebSpeechRecognizerClient::OtherError;
-    case content::SPEECH_RECOGNITION_ERROR_BAD_GRAMMAR:
+    case SPEECH_RECOGNITION_ERROR_BAD_GRAMMAR:
       return WebSpeechRecognizerClient::BadGrammarError;
   }
   NOTREACHED();
   return WebSpeechRecognizerClient::OtherError;
 }
 
 void SpeechRecognitionDispatcher::OnErrorOccurred(
     int request_id, const SpeechRecognitionError& error) {
-  if (error.code == content::SPEECH_RECOGNITION_ERROR_NO_MATCH) {
+  if (error.code == SPEECH_RECOGNITION_ERROR_NO_MATCH) {
     recognizer_client_->didReceiveNoMatch(GetHandleFromID(request_id),
                                           WebSpeechRecognitionResult());
   } else {
     recognizer_client_->didReceiveError(GetHandleFromID(request_id),
                                         WebString(), // TODO(primiano): message?
                                         WebKitErrorCode(error.code));
   }
 }
 
 void SpeechRecognitionDispatcher::OnRecognitionEnded(int request_id) {
@@ skipping 47 matching lines @@
   }
   return false;
 }
 
 const WebSpeechRecognitionHandle& SpeechRecognitionDispatcher::GetHandleFromID(
     int request_id) {
   HandleMap::iterator iter = handle_map_.find(request_id);
   DCHECK(iter != handle_map_.end());
   return iter->second;
 }
+
+}  // namespace content