Move a bunch of code in content\renderer to the 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 13 matching lines @@
 #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/WebMediaStreamDescriptor.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 {
 
 const int kVideoCaptureWidth = 640;
 const int kVideoCaptureHeight = 480;
 const int kVideoCaptureFramePerSecond = 30;
 
 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) {
-  if (options->audio_type != content::MEDIA_NO_SERVICE &&
+  if (options->audio_type != MEDIA_NO_SERVICE &&
       GetMandatoryStreamConstraint(user_media_request.audioConstraints(),
                                    media_stream::kMediaStreamSource) ==
           media_stream::kMediaStreamSourceTab) {
-    options->audio_type = content::MEDIA_TAB_AUDIO_CAPTURE;
+    options->audio_type = MEDIA_TAB_AUDIO_CAPTURE;
     options->audio_device_id = GetMandatoryStreamConstraint(
         user_media_request.audioConstraints(),
         media_stream::kMediaStreamSourceId);
   }
 
-  if (options->video_type != content::MEDIA_NO_SERVICE &&
+  if (options->video_type != MEDIA_NO_SERVICE &&
       GetMandatoryStreamConstraint(user_media_request.videoConstraints(),
                                    media_stream::kMediaStreamSource) ==
           media_stream::kMediaStreamSourceTab) {
-    options->video_type = content::MEDIA_TAB_VIDEO_CAPTURE;
+    options->video_type = MEDIA_TAB_VIDEO_CAPTURE;
     options->video_device_id = GetMandatoryStreamConstraint(
         user_media_request.videoConstraints(),
         media_stream::kMediaStreamSourceId);
   }
 }
 
 }  // namespace
 
 static int g_next_request_id  = 0;
 
@@ skipping 11 matching lines @@
     webkit_sources[i].initialize(
           UTF8ToUTF16(source_id),
           type,
           UTF8ToUTF16(devices[i].name));
     webkit_sources[i].setExtraData(
         new MediaStreamSourceExtraData(devices[i]));
   }
 }
 
 MediaStreamImpl::MediaStreamImpl(
-    content::RenderView* render_view,
+    RenderView* render_view,
     MediaStreamDispatcher* media_stream_dispatcher,
     VideoCaptureImplManager* vc_manager,
     MediaStreamDependencyFactory* dependency_factory)
-    : content::RenderViewObserver(render_view),
+    : RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher),
       vc_manager_(vc_manager) {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
 }
 
 void MediaStreamImpl::OnLocalMediaStreamStop(
     const std::string& label) {
   DVLOG(1) << "MediaStreamImpl::OnLocalMediaStreamStop";
   media_stream_dispatcher_->StopStream(label);
   local_media_streams_.erase(label);
 }
 
 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(content::MEDIA_NO_SERVICE,
-                                      content::MEDIA_NO_SERVICE);
+  media_stream::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 = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+      options.audio_type = MEDIA_DEVICE_AUDIO_CAPTURE;
     if (video_sources.size() > 0)
-      options.video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
+      options.video_type = MEDIA_DEVICE_VIDEO_CAPTURE;
   } else {
     if (user_media_request.audio())
-      options.audio_type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+      options.audio_type = MEDIA_DEVICE_AUDIO_CAPTURE;
     if (user_media_request.video())
-      options.video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
+      options.video_type = MEDIA_DEVICE_VIDEO_CAPTURE;
 
     security_origin = GURL(user_media_request.securityOrigin().toString());
     // Get the WebFrame that requested a MediaStream.
     // The frame is needed to tell the MediaStreamDispatcher when a stream goes
     // out of scope.
     frame = user_media_request.ownerDocument().frame();
     DCHECK(frame);
 
     UpdateOptionsIfTabMediaRequest(user_media_request, &options);
   }
@@ skipping 241 matching lines @@
   capability.width = kVideoCaptureWidth;
   capability.height = kVideoCaptureHeight;
   capability.frame_rate = kVideoCaptureFramePerSecond;
   capability.color = media::VideoCaptureCapability::kI420;
   capability.expected_capture_delay = 0;
   capability.interlaced = false;
 
   DVLOG(1) << "MediaStreamImpl::CreateLocalVideoFrameProvider video_session_id:"
            << video_session_id;
 
-  return new content::LocalVideoCapture(
+  return new LocalVideoCapture(
       video_session_id,
       vc_manager_.get(),
       capability,
       error_cb,
       repaint_cb);
 }
 
 scoped_refptr<webkit_media::VideoFrameProvider>
 MediaStreamImpl::CreateRemoteVideoFrameProvider(
     webrtc::MediaStreamInterface* stream,
     const base::Closure& error_cb,
     const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoFrameProvider label:"
            << stream->label();
 
-  return new content::RTCVideoRenderer(
+  return new RTCVideoRenderer(
       stream->video_tracks()->at(0),
       error_cb,
       repaint_cb);
 }
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateLocalVideoDecoder(
     webrtc::MediaStreamInterface* stream,
     media::MessageLoopFactory* message_loop_factory) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
@@ skipping 49 matching lines @@
 
 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