Move content\browser\renderer_host\media to 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"
@@ skipping 11 matching lines @@
   }
   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
   int request_id;
   int ipc_request;
 };
 
 struct MediaStreamDispatcher::Stream {
   Stream() {}
   ~Stream() {}
   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
-  media_stream::StreamDeviceInfoArray audio_array;
-  media_stream::StreamDeviceInfoArray video_array;
+  StreamDeviceInfoArray audio_array;
+  StreamDeviceInfoArray video_array;
 };
 
 MediaStreamDispatcher::EnumerationRequest::EnumerationRequest(
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
     int request_id)
     : handler(handler),
       request_id(request_id) {
 }
 
 MediaStreamDispatcher::EnumerationRequest::~EnumerationRequest() {}
 
 MediaStreamDispatcher::EnumerationState::EnumerationState()
     : ipc_id(-1) {
 }
 
 MediaStreamDispatcher::EnumerationState::~EnumerationState() {}
 
 struct MediaStreamDispatcher::EnumerationState::CachedDevices {
   CachedDevices(const std::string& label,
-                const media_stream::StreamDeviceInfoArray& device_array)
+                const StreamDeviceInfoArray& device_array)
       : label(label),
         devices(device_array) {
   }
   ~CachedDevices() {}
 
   std::string label;
-  media_stream::StreamDeviceInfoArray devices;
+  StreamDeviceInfoArray devices;
 };
 
 MediaStreamDispatcher::MediaStreamDispatcher(RenderViewImpl* 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,
+    const StreamOptions& components,
     const GURL& security_origin) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::GenerateStream(" << request_id << ")";
 
   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
   Send(new MediaStreamHostMsg_GenerateStream(routing_id(),
                                              next_ipc_id_++,
                                              components,
                                              security_origin));
 }
@@ skipping 24 matching lines @@
   if (it == label_stream_map_.end())
     return;
 
   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,
+    MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
            << request_id << ")";
 
   EnumerationState* state =
       (type == MEDIA_DEVICE_AUDIO_CAPTURE ?
        &audio_enumeration_state_ : &video_enumeration_state_);
@@ skipping 44 matching lines @@
       }
       return;
     }
   }
 }
 
 void MediaStreamDispatcher::OpenDevice(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     const std::string& device_id,
-    media_stream::MediaStreamType type,
+    MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::OpenDevice(" << request_id << ")";
 
   requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
   Send(new MediaStreamHostMsg_OpenDevice(routing_id(),
                                          next_ipc_id_++,
                                          device_id,
                                          type,
                                          security_origin));
@@ skipping 23 matching lines @@
     IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpenFailed,
                         OnDeviceOpenFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MediaStreamDispatcher::OnStreamGenerated(
     int request_id,
     const std::string& label,
-    const media_stream::StreamDeviceInfoArray& audio_array,
-    const media_stream::StreamDeviceInfoArray& video_array) {
+    const StreamDeviceInfoArray& audio_array,
+    const StreamDeviceInfoArray& video_array) {
   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;
       new_stream.audio_array = audio_array;
       new_stream.video_array = video_array;
@@ skipping 23 matching lines @@
       }
       requests_.erase(it);
       break;
     }
   }
 }
 
 void MediaStreamDispatcher::OnDevicesEnumerated(
     int request_id,
     const std::string& label,
-    const media_stream::StreamDeviceInfoArray& device_array) {
+    const StreamDeviceInfoArray& device_array) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK_GE(request_id, 0);
 
   EnumerationState* state;
   if (request_id == audio_enumeration_state_.ipc_id) {
     state = &audio_enumeration_state_;
   } else if (request_id == video_enumeration_state_.ipc_id) {
     state = &video_enumeration_state_;
   } else {
     // This could happen when requester has stopped enumeration while some
@@ skipping 31 matching lines @@
       }
       requests_.erase(it);
       break;
     }
   }
 }
 
 void MediaStreamDispatcher::OnDeviceOpened(
     int request_id,
     const std::string& label,
-    const media_stream::StreamDeviceInfo& device_info) {
+    const 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 (IsAudioMediaType(device_info.stream_type)) {
         new_stream.audio_array.push_back(device_info);
       } else if (IsVideoMediaType(device_info.stream_type)) {
@@ skipping 28 matching lines @@
       requests_.erase(it);
       break;
     }
   }
 }
 
 int MediaStreamDispatcher::audio_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;
+    return StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.audio_array.size(), static_cast<size_t>(index));
   return it->second.audio_array[index].session_id;
 }
 
 bool MediaStreamDispatcher::IsStream(const std::string& label) {
   return label_stream_map_.find(label) != label_stream_map_.end();
 }
 
 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;
+    return StreamDeviceInfo::kNoId;
 
   DCHECK_GT(it->second.video_array.size(), static_cast<size_t>(index));
   return it->second.video_array[index].session_id;
 }
 
 }  // namespace content