Move content\browser\renderer_host\media to content namespace.

content/renderer/media/media_stream_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 10 matching lines @@
 #include "media/base/message_loop_factory.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
+namespace content {
 namespace {
 
 std::string GetMandatoryStreamConstraint(
     const WebKit::WebMediaConstraints& constraints, const std::string& key) {
   if (constraints.isNull())
     return std::string();
 
   WebKit::WebString value;
   constraints.getMandatoryConstraintValue(UTF8ToUTF16(key), value);
   return UTF16ToUTF8(value);
 }
 
 void UpdateOptionsIfTabMediaRequest(
     const WebKit::WebUserMediaRequest& user_media_request,
-    media_stream::StreamOptions* options) {
+    StreamOptions* options) {
   if (options->audio_type != content::MEDIA_NO_SERVICE &&
       GetMandatoryStreamConstraint(user_media_request.audioConstraints(),
-                                   media_stream::kMediaStreamSource) ==
-          media_stream::kMediaStreamSourceTab) {
+                                   kMediaStreamSource) ==
+          kMediaStreamSourceTab) {
     options->audio_type = content::MEDIA_TAB_AUDIO_CAPTURE;
     options->audio_device_id = GetMandatoryStreamConstraint(
         user_media_request.audioConstraints(),
-        media_stream::kMediaStreamSourceId);
+        kMediaStreamSourceId);
   }
 
   if (options->video_type != content::MEDIA_NO_SERVICE &&
       GetMandatoryStreamConstraint(user_media_request.videoConstraints(),
-                                   media_stream::kMediaStreamSource) ==
-          media_stream::kMediaStreamSourceTab) {
+                                   kMediaStreamSource) ==
+          kMediaStreamSourceTab) {
     options->video_type = content::MEDIA_TAB_VIDEO_CAPTURE;
     options->video_device_id = GetMandatoryStreamConstraint(
         user_media_request.videoConstraints(),
-        media_stream::kMediaStreamSourceId);
+        kMediaStreamSourceId);
   }
 }
 
 static int g_next_request_id  = 0;
 
 // Creates a WebKit representation of a stream sources based on
 // |devices| from the MediaStreamDispatcher.
 void CreateWebKitSourceVector(
     const std::string& label,
-    const media_stream::StreamDeviceInfoArray& devices,
+    const StreamDeviceInfoArray& devices,
     WebKit::WebMediaStreamSource::Type type,
     WebKit::WebVector<WebKit::WebMediaStreamSource>& webkit_sources) {
   CHECK_EQ(devices.size(), webkit_sources.size());
   for (size_t i = 0; i < devices.size(); ++i) {
     std::string source_id = StringPrintf("%s%d%u", label.c_str(), type,
                                          static_cast<unsigned int>(i));
     webkit_sources[i].initialize(
           UTF8ToUTF16(source_id),
           type,
           UTF8ToUTF16(devices[i].name));
     webkit_sources[i].setExtraData(
         new content::MediaStreamSourceExtraData(devices[i]));
   }
 }
 
 webrtc::MediaStreamInterface* GetNativeMediaStream(
     const WebKit::WebMediaStreamDescriptor& descriptor) {
   content::MediaStreamExtraData* extra_data =
       static_cast<content::MediaStreamExtraData*>(descriptor.extraData());
   if (!extra_data)
     return NULL;
   webrtc::MediaStreamInterface* stream = extra_data->local_stream();
   if (!stream)
     stream = extra_data->remote_stream();
   return stream;
 }
 
 }  // namespace
 
-namespace content {
-
 MediaStreamImpl::MediaStreamImpl(
     RenderView* render_view,
     MediaStreamDispatcher* media_stream_dispatcher,
     VideoCaptureImplManager* vc_manager,
     MediaStreamDependencyFactory* dependency_factory)
     : RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher),
       vc_manager_(vc_manager) {
 }
@@ skipping 15 matching lines @@
 void MediaStreamImpl::requestUserMedia(
     const WebKit::WebUserMediaRequest& user_media_request,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& audio_sources,
     const WebKit::WebVector<WebKit::WebMediaStreamSource>& video_sources) {
   // Save histogram data so we can see how much GetUserMedia is used.
   // The histogram counts the number of calls to the JS API
   // webGetUserMedia.
   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
   DCHECK(CalledOnValidThread());
   int request_id = g_next_request_id++;
-  media_stream::StreamOptions options(MEDIA_NO_SERVICE, MEDIA_NO_SERVICE);
+  StreamOptions options(MEDIA_NO_SERVICE, MEDIA_NO_SERVICE);
   WebKit::WebFrame* frame = NULL;
   GURL security_origin;
 
   // |user_media_request| can't be mocked. So in order to test at all we check
   // if it isNull.
   if (user_media_request.isNull()) {
     // We are in a test.
     if (audio_sources.size() > 0)
       options.audio_type = MEDIA_DEVICE_AUDIO_CAPTURE;
     if (video_sources.size() > 0)
@@ skipping 102 matching lines @@
     return CreateVideoDecoder(stream, message_loop_factory);
   NOTREACHED();
   return NULL;
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated by the MediaStreamDispatcher.
 void MediaStreamImpl::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(CalledOnValidThread());
 
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     // We need to tell the dispatcher to stop the stream.
     media_stream_dispatcher_->StopStream(label);
     DVLOG(1) << "Request ID not found";
     return;
@@ skipping 70 matching lines @@
   }
   CompleteGetUserMediaRequest(request_info->descriptor, &request_info->request,
                               request_succeeded);
   if (!request_succeeded) {
     OnLocalMediaStreamStop(UTF16ToUTF8(description->label()));
   }
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
-    const media_stream::StreamDeviceInfoArray& device_array) {
+    const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDevicesEnumerationFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerationFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
-    const media_stream::StreamDeviceInfo& video_device) {
+    const StreamDeviceInfo& video_device) {
   DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
@@ skipping 114 matching lines @@
   DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoDecoder label:"
            << stream->label();
 
   return new RTCVideoDecoder(
       message_loop_factory->GetMessageLoop(media::MessageLoopFactory::kDecoder),
       base::MessageLoopProxy::current(),
       stream->video_tracks()->at(0));
 }
 
 MediaStreamSourceExtraData::MediaStreamSourceExtraData(
-    const media_stream::StreamDeviceInfo& device_info)
+    const StreamDeviceInfo& device_info)
     : device_info_(device_info) {
 }
 
 MediaStreamSourceExtraData::~MediaStreamSourceExtraData() {}
 
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::MediaStreamInterface* remote_stream)
     : remote_stream_(remote_stream) {
 }
 
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::LocalMediaStreamInterface* local_stream)
     : local_stream_(local_stream) {
 }
 
 MediaStreamExtraData::~MediaStreamExtraData() {
 }
 
 void MediaStreamExtraData::SetLocalStreamStopCallback(
     const StreamStopCallback& stop_callback) {
   stream_stop_callback_ = stop_callback;
 }
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
     stream_stop_callback_.Run(local_stream_->label());
 }
 
 }  // namespace content