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

content/renderer/media/media_stream_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/media/media_stream_dispatcher.h"
 
 #include "base/logging.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "content/renderer/render_view_impl.h"
 #include "googleurl/src/gurl.h"
 
+namespace content {
+
 struct MediaStreamDispatcher::Request {
   Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
           int request_id,
           int ipc_request)
       : handler(handler),
         request_id(request_id),
         ipc_request(ipc_request) {
   }
   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
   int request_id;
@@ skipping 29 matching lines @@
       : label(label),
         devices(device_array) {
   }
   ~CachedDevices() {}
 
   std::string label;
   media_stream::StreamDeviceInfoArray devices;
 };
 
 MediaStreamDispatcher::MediaStreamDispatcher(RenderViewImpl* render_view)
-    : content::RenderViewObserver(render_view),
+    : RenderViewObserver(render_view),
       main_loop_(base::MessageLoopProxy::current()),
       next_ipc_id_(0) {
 }
 
 MediaStreamDispatcher::~MediaStreamDispatcher() {}
 
 void MediaStreamDispatcher::GenerateStream(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     const media_stream::StreamOptions& components,
@@ skipping 37 matching lines @@
   Send(new MediaStreamHostMsg_StopGeneratedStream(routing_id(), label));
   label_stream_map_.erase(it);
 }
 
 void MediaStreamDispatcher::EnumerateDevices(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     media_stream::MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(main_loop_->BelongsToCurrentThread());
-  DCHECK(type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
-         type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
+  DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
+         type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
            << request_id << ")";
 
   EnumerationState* state =
-      (type == content::MEDIA_DEVICE_AUDIO_CAPTURE ?
+      (type == MEDIA_DEVICE_AUDIO_CAPTURE ?
        &audio_enumeration_state_ : &video_enumeration_state_);
   state->requests.push_back(EnumerationRequest(event_handler, request_id));
 
   if (state->cached_devices.get()) {
     event_handler->OnDevicesEnumerated(
         request_id, state->cached_devices->devices);
   } else if (state->ipc_id < 0) {
     Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
                                                  next_ipc_id_,
                                                  type,
@@ skipping 184 matching lines @@
     int request_id,
     const std::string& label,
     const media_stream::StreamDeviceInfo& device_info) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   for (RequestList::iterator it = requests_.begin();
        it != requests_.end(); ++it) {
     Request& request = *it;
     if (request.ipc_request == request_id) {
       Stream new_stream;
       new_stream.handler = request.handler;
-      if (content::IsAudioMediaType(device_info.stream_type)) {
+      if (IsAudioMediaType(device_info.stream_type)) {
         new_stream.audio_array.push_back(device_info);
-      } else if (content::IsVideoMediaType(device_info.stream_type)) {
+      } else if (IsVideoMediaType(device_info.stream_type)) {
         new_stream.video_array.push_back(device_info);
       } else {
         NOTREACHED();
       }
       label_stream_map_[label] = new_stream;
       if (request.handler) {
         request.handler->OnDeviceOpened(request.request_id, label,
                                         device_info);
         DVLOG(1) << "MediaStreamDispatcher::OnDeviceOpened("
                  << request.request_id << ", " << label << ")";
@@ skipping 37 matching lines @@
 
 int MediaStreamDispatcher::video_session_id(const std::string& label,
                                             int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     return media_stream::StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.video_array.size(), static_cast<size_t>(index));
   return it->second.video_array[index].session_id;
 }
+
+}  // namespace content