Changed name of MediaStreamImpl to UserMediaClientImpl.

content/renderer/media/user_media_client_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[Henrik Grunell, 2014/09/02 06:47:53]

Same here.

 // 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 "content/renderer/media/user_media_client_impl.h"
 
 #include <utility>
 
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/renderer/render_frame.h"
@@ skipping 34 matching lines @@
     optional->push_back(StreamOptions::Constraint(
         optional_constraints[i].m_name.utf8(),
         optional_constraints[i].m_value.utf8()));
   }
 }
 
 static int g_next_request_id  = 0;
 
 }  // namespace
 
-struct MediaStreamImpl::MediaDevicesRequestInfo {
+struct UserMediaClientImpl::MediaDevicesRequestInfo {
   MediaDevicesRequestInfo(const blink::WebMediaDevicesRequest& request,
                           int audio_input_request_id,
                           int video_input_request_id,
                           int audio_output_request_id)
       : request(request),
         audio_input_request_id(audio_input_request_id),
         video_input_request_id(video_input_request_id),
         audio_output_request_id(audio_output_request_id),
         has_audio_input_returned(false),
         has_video_input_returned(false),
         has_audio_output_returned(false) {}
 
   blink::WebMediaDevicesRequest request;
   int audio_input_request_id;
   int video_input_request_id;
   int audio_output_request_id;
   bool has_audio_input_returned;
   bool has_video_input_returned;
   bool has_audio_output_returned;
   StreamDeviceInfoArray audio_input_devices;
   StreamDeviceInfoArray video_input_devices;
   StreamDeviceInfoArray audio_output_devices;
 };
 
-MediaStreamImpl::MediaStreamImpl(
+UserMediaClientImpl::UserMediaClientImpl(
     RenderFrame* render_frame,
     PeerConnectionDependencyFactory* dependency_factory,
     scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher)
     : RenderFrameObserver(render_frame),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher.Pass()),
       weak_factory_(this) {
   DCHECK(dependency_factory_);
   DCHECK(media_stream_dispatcher_.get());
 }
 
-MediaStreamImpl::~MediaStreamImpl() {
+UserMediaClientImpl::~UserMediaClientImpl() {
   // Force-close all outstanding user media requests and local sources here,
   // before the outstanding WeakPtrs are invalidated, to ensure a clean
   // shutdown.
   FrameWillClose();
 }
 
-void MediaStreamImpl::requestUserMedia(
+void UserMediaClientImpl::requestUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
   // 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());
 
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
         user_media_request);
@@ skipping 32 matching lines @@
                             &options.mandatory_video,
                             &options.optional_video);
     }
 
     security_origin = GURL(user_media_request.securityOrigin().toString());
     DCHECK(render_frame()->GetWebFrame() ==
                static_cast<blink::WebFrame*>(
                    user_media_request.ownerDocument().frame()));
   }
 
-  DVLOG(1) << "MediaStreamImpl::requestUserMedia(" << request_id << ", [ "
+  DVLOG(1) << "UserMediaClientImpl::requestUserMedia(" << request_id << ", [ "
            << "audio=" << (options.audio_requested)
            << " select associated sink: "
            << enable_automatic_output_device_selection
            << ", video=" << (options.video_requested) << " ], "
            << security_origin.spec() << ")";
 
   std::string audio_device_id;
   bool mandatory_audio;
   options.GetFirstAudioConstraintByName(kMediaStreamSourceInfoId,
                                         &audio_device_id, &mandatory_audio);
@@ skipping 16 matching lines @@
       new UserMediaRequestInfo(request_id, user_media_request,
                                enable_automatic_output_device_selection));
 
   media_stream_dispatcher_->GenerateStream(
       request_id,
       weak_factory_.GetWeakPtr(),
       options,
       security_origin);
 }
 
-void MediaStreamImpl::cancelUserMediaRequest(
+void UserMediaClientImpl::cancelUserMediaRequest(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
   if (request) {
     // We can't abort the stream generation process.
     // Instead, erase the request. Once the stream is generated we will stop the
     // stream if the request does not exist.
     LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_EXPLICITLY_CANCELLED);
     DeleteUserMediaRequestInfo(request);
   }
 }
 
-void MediaStreamImpl::requestMediaDevices(
+void UserMediaClientImpl::requestMediaDevices(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   UpdateWebRTCMethodCount(WEBKIT_GET_MEDIA_DEVICES);
   DCHECK(CalledOnValidThread());
 
   int audio_input_request_id = g_next_request_id++;
   int video_input_request_id = g_next_request_id++;
   int audio_output_request_id = g_next_request_id++;
 
   // |media_devices_request| can't be mocked, so in tests it will be empty (the
   // underlying pointer is null). In order to use this function in a test we
   // need to check if it isNull.
   GURL security_origin;
   if (!media_devices_request.isNull())
     security_origin = GURL(media_devices_request.securityOrigin().toString());
 
-  DVLOG(1) << "MediaStreamImpl::requestMediaDevices(" << audio_input_request_id
+  DVLOG(1) << "UserMediaClientImpl::requestMediaDevices("
+           << audio_input_request_id
            << ", " << video_input_request_id << ", " << audio_output_request_id
            << ", " << security_origin.spec() << ")";
 
   media_devices_requests_.push_back(new MediaDevicesRequestInfo(
       media_devices_request,
       audio_input_request_id,
       video_input_request_id,
       audio_output_request_id));
 
   media_stream_dispatcher_->EnumerateDevices(
       audio_input_request_id,
       weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_AUDIO_CAPTURE,
       security_origin);
 
   media_stream_dispatcher_->EnumerateDevices(
       video_input_request_id,
       weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_VIDEO_CAPTURE,
       security_origin);
 
   media_stream_dispatcher_->EnumerateDevices(
       audio_output_request_id,
       weak_factory_.GetWeakPtr(),
       MEDIA_DEVICE_AUDIO_OUTPUT,
       security_origin);
 }
 
-void MediaStreamImpl::cancelMediaDevicesRequest(
+void UserMediaClientImpl::cancelMediaDevicesRequest(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   DCHECK(CalledOnValidThread());
   MediaDevicesRequestInfo* request =
       FindMediaDevicesRequestInfo(media_devices_request);
   if (!request)
     return;
   CancelAndDeleteMediaDevicesRequest(request);
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated by the MediaStreamDispatcher.
-void MediaStreamImpl::OnStreamGenerated(
+void UserMediaClientImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "MediaStreamImpl::OnStreamGenerated stream:" << label;
+  DVLOG(1) << "UserMediaClientImpl::OnStreamGenerated stream:" << label;
 
   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.
     DVLOG(1) << "Request ID not found";
     OnStreamGeneratedForCancelledRequest(audio_array, video_array);
     return;
   }
   request_info->generated = true;
@@ skipping 26 matching lines @@
   blink::WebMediaStream* web_stream = &(request_info->web_stream);
 
   web_stream->initialize(webkit_id, audio_track_vector,
                          video_track_vector);
   web_stream->setExtraData(
       new MediaStream(
           *web_stream));
 
   // Wait for the tracks to be started successfully or to fail.
   request_info->CallbackOnTracksStarted(
-      base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted,
+      base::Bind(&UserMediaClientImpl::OnCreateNativeTracksCompleted,
                  weak_factory_.GetWeakPtr()));
 }
 
-void MediaStreamImpl::OnStreamGeneratedForCancelledRequest(
+void UserMediaClientImpl::OnStreamGeneratedForCancelledRequest(
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   // Only stop the device if the device is not used in another MediaStream.
   for (StreamDeviceInfoArray::const_iterator device_it = audio_array.begin();
        device_it != audio_array.end(); ++device_it) {
     if (!FindLocalSource(*device_it))
       media_stream_dispatcher_->StopStreamDevice(*device_it);
   }
 
   for (StreamDeviceInfoArray::const_iterator device_it = video_array.begin();
        device_it != video_array.end(); ++device_it) {
     if (!FindLocalSource(*device_it))
       media_stream_dispatcher_->StopStreamDevice(*device_it);
   }
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
-void MediaStreamImpl::OnStreamGenerationFailed(
+void UserMediaClientImpl::OnStreamGenerationFailed(
     int request_id,
     MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
+  DVLOG(1) << "UserMediaClientImpl::OnStreamGenerationFailed("
            << request_id << ")";
   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.
     DVLOG(1) << "Request ID not found";
     return;
   }
 
   GetUserMediaRequestFailed(&request_info->request, result);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
-void MediaStreamImpl::OnDeviceStopped(
+void UserMediaClientImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "MediaStreamImpl::OnDeviceStopped("
+  DVLOG(1) << "UserMediaClientImpl::OnDeviceStopped("
            << "{device_id = " << device_info.device.id << "})";
 
   const blink::WebMediaStreamSource* source_ptr = FindLocalSource(device_info);
   if (!source_ptr) {
     // This happens if the same device is used in several guM requests or
     // if a user happen stop a track from JS at the same time
     // as the underlying media device is unplugged from the system.
     return;
   }
   // By creating |source| it is guaranteed that the blink::WebMediaStreamSource
   // object is valid during the cleanup.
   blink::WebMediaStreamSource source(*source_ptr);
   StopLocalSource(source, false);
 
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
     if (device_it->id() == source.id()) {
       local_sources_.erase(device_it);
       break;
     }
   }
 }
 
-void MediaStreamImpl::InitializeSourceObject(
+void UserMediaClientImpl::InitializeSourceObject(
     const StreamDeviceInfo& device,
     blink::WebMediaStreamSource::Type type,
     const blink::WebMediaConstraints& constraints,
     blink::WebMediaStreamSource* webkit_source) {
   const blink::WebMediaStreamSource* existing_source =
       FindLocalSource(device);
   if (existing_source) {
     *webkit_source = *existing_source;
     DVLOG(1) << "Source already exist. Reusing source with id "
              << webkit_source->id().utf8();
     return;
   }
 
   webkit_source->initialize(
       base::UTF8ToUTF16(device.device.id),
       type,
       base::UTF8ToUTF16(device.device.name));
 
   DVLOG(1) << "Initialize source object :"
            << "id = " << webkit_source->id().utf8()
            << ", name = " << webkit_source->name().utf8();
 
   if (type == blink::WebMediaStreamSource::TypeVideo) {
     webkit_source->setExtraData(
         CreateVideoSource(
             device,
-            base::Bind(&MediaStreamImpl::OnLocalSourceStopped,
+            base::Bind(&UserMediaClientImpl::OnLocalSourceStopped,
                        weak_factory_.GetWeakPtr())));
   } else {
     DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio, type);
     MediaStreamAudioSource* audio_source(
         new MediaStreamAudioSource(
             RenderFrameObserver::routing_id(),
             device,
-            base::Bind(&MediaStreamImpl::OnLocalSourceStopped,
+            base::Bind(&UserMediaClientImpl::OnLocalSourceStopped,
                        weak_factory_.GetWeakPtr()),
             dependency_factory_));
     webkit_source->setExtraData(audio_source);
   }
   local_sources_.push_back(*webkit_source);
 }
 
-MediaStreamVideoSource* MediaStreamImpl::CreateVideoSource(
+MediaStreamVideoSource* UserMediaClientImpl::CreateVideoSource(
     const StreamDeviceInfo& device,
     const MediaStreamSource::SourceStoppedCallback& stop_callback) {
   return new content::MediaStreamVideoCapturerSource(
       device,
       stop_callback,
       new VideoCapturerDelegate(device));
 }
 
-void MediaStreamImpl::CreateVideoTracks(
+void UserMediaClientImpl::CreateVideoTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
     UserMediaRequestInfo* request) {
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   for (size_t i = 0; i < devices.size(); ++i) {
     blink::WebMediaStreamSource webkit_source;
     InitializeSourceObject(devices[i],
                            blink::WebMediaStreamSource::TypeVideo,
                            constraints,
                            &webkit_source);
     (*webkit_tracks)[i] =
         request->CreateAndStartVideoTrack(webkit_source, constraints);
   }
 }
 
-void MediaStreamImpl::CreateAudioTracks(
+void UserMediaClientImpl::CreateAudioTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
     UserMediaRequestInfo* request) {
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   // Log the device names for this request.
   for (StreamDeviceInfoArray::const_iterator it = devices.begin();
        it != devices.end(); ++it) {
     WebRtcLogMessage(base::StringPrintf(
@@ skipping 19 matching lines @@
     blink::WebMediaStreamSource webkit_source;
     InitializeSourceObject(overridden_audio_array[i],
                            blink::WebMediaStreamSource::TypeAudio,
                            constraints,
                            &webkit_source);
     (*webkit_tracks)[i].initialize(webkit_source);
     request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
-void MediaStreamImpl::OnCreateNativeTracksCompleted(
+void UserMediaClientImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
-  DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
+  DVLOG(1) << "UserMediaClientImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{result = " << result << "})";
   if (result == content::MEDIA_DEVICE_OK)
     GetUserMediaRequestSucceeded(request->web_stream, &request->request);
   else
     GetUserMediaRequestTrackStartedFailed(&request->request,
                                           result,
                                           result_name);
 
   DeleteUserMediaRequestInfo(request);
 }
 
-void MediaStreamImpl::OnDevicesEnumerated(
+void UserMediaClientImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
-  DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated(" << request_id << ")";
+  DVLOG(1) << "UserMediaClientImpl::OnDevicesEnumerated(" << request_id << ")";
 
   MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
   DCHECK(request);
 
   if (request_id == request->audio_input_request_id) {
     request->has_audio_input_returned = true;
     DCHECK(request->audio_input_devices.empty());
     request->audio_input_devices = device_array;
   } else if (request_id == request->video_input_request_id) {
     request->has_video_input_returned = true;
@@ skipping 52 matching lines @@
         blink::WebString::fromUTF8(device.id),
         blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
         blink::WebString::fromUTF8(device.name),
         blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
   }
 
   EnumerateDevicesSucceded(&request->request, devices);
   CancelAndDeleteMediaDevicesRequest(request);
 }
 
-void MediaStreamImpl::OnDeviceOpened(
+void UserMediaClientImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
-  DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
+  DVLOG(1) << "UserMediaClientImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
 
-void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
-  DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
+void UserMediaClientImpl::OnDeviceOpenFailed(int request_id) {
+  DVLOG(1) << "UserMediaClientImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
-void MediaStreamImpl::GetUserMediaRequestSucceeded(
+void UserMediaClientImpl::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
     blink::WebUserMediaRequest* request_info) {
-  DVLOG(1) << "MediaStreamImpl::GetUserMediaRequestSucceeded";
+  DVLOG(1) << "UserMediaClientImpl::GetUserMediaRequestSucceeded";
   LogUserMediaRequestResult(MEDIA_DEVICE_OK);
   request_info->requestSucceeded(stream);
 }
 
-void MediaStreamImpl::GetUserMediaRequestFailed(
+void UserMediaClientImpl::GetUserMediaRequestFailed(
     blink::WebUserMediaRequest* request_info,
     MediaStreamRequestResult result) {
   LogUserMediaRequestResult(result);
   switch (result) {
     case MEDIA_DEVICE_OK:
       NOTREACHED();
       break;
     case MEDIA_DEVICE_PERMISSION_DENIED:
       request_info->requestDenied();
       break;
@@ skipping 18 matching lines @@
     case MEDIA_DEVICE_CAPTURE_FAILURE:
       request_info->requestFailedUASpecific("DeviceCaptureError");
       break;
     default:
       NOTREACHED();
       request_info->requestFailed();
       break;
   }
 }
 
-void MediaStreamImpl::GetUserMediaRequestTrackStartedFailed(
+void UserMediaClientImpl::GetUserMediaRequestTrackStartedFailed(
     blink::WebUserMediaRequest* request_info,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   switch (result) {
     case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
       request_info->requestFailedConstraint(result_name);
       break;
     case MEDIA_DEVICE_TRACK_START_FAILURE:
       request_info->requestFailedUASpecific("TrackStartError");
       break;
     default:
       NOTREACHED();
       request_info->requestFailed();
       break;
   }
 }
 
-void MediaStreamImpl::EnumerateDevicesSucceded(
+void UserMediaClientImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
 
-const blink::WebMediaStreamSource* MediaStreamImpl::FindLocalSource(
+const blink::WebMediaStreamSource* UserMediaClientImpl::FindLocalSource(
     const StreamDeviceInfo& device) const {
   for (LocalStreamSources::const_iterator it = local_sources_.begin();
        it != local_sources_.end(); ++it) {
     MediaStreamSource* const source =
         static_cast<MediaStreamSource*>(it->extraData());
     const StreamDeviceInfo& active_device = source->device_info();
     if (active_device.device.id == device.device.id &&
         active_device.device.type == device.device.type &&
         active_device.session_id == device.session_id) {
       return &(*it);
     }
   }
   return NULL;
 }
 
-MediaStreamImpl::UserMediaRequestInfo*
-MediaStreamImpl::FindUserMediaRequestInfo(int request_id) {
+UserMediaClientImpl::UserMediaRequestInfo*
+UserMediaClientImpl::FindUserMediaRequestInfo(int request_id) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->request_id == request_id)
       return (*it);
   }
   return NULL;
 }
 
-MediaStreamImpl::UserMediaRequestInfo*
-MediaStreamImpl::FindUserMediaRequestInfo(
+UserMediaClientImpl::UserMediaRequestInfo*
+UserMediaClientImpl::FindUserMediaRequestInfo(
     const blink::WebUserMediaRequest& request) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->request == request)
       return (*it);
   }
   return NULL;
 }
 
-void MediaStreamImpl::DeleteUserMediaRequestInfo(
+void UserMediaClientImpl::DeleteUserMediaRequestInfo(
     UserMediaRequestInfo* request) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it) == request) {
       user_media_requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
-void MediaStreamImpl::DeleteAllUserMediaRequests() {
+void UserMediaClientImpl::DeleteAllUserMediaRequests() {
   UserMediaRequests::iterator request_it = user_media_requests_.begin();
   while (request_it != user_media_requests_.end()) {
-    DVLOG(1) << "MediaStreamImpl@" << this << "::DeleteAllUserMediaRequests: "
+    DVLOG(1) << "UserMediaClientImpl@" << this
+             << "::DeleteAllUserMediaRequests: "
              << "Cancel user media request " << (*request_it)->request_id;
     // If the request is not generated, it means that a request
     // has been sent to the MediaStreamDispatcher to generate a stream
     // but MediaStreamDispatcher has not yet responded and we need to cancel
     // the request.
     if (!(*request_it)->generated) {
       DCHECK(!(*request_it)->HasPendingSources());
       media_stream_dispatcher_->CancelGenerateStream(
           (*request_it)->request_id, weak_factory_.GetWeakPtr());
       LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED);
     } else {
       DCHECK((*request_it)->HasPendingSources());
       LogUserMediaRequestWithNoResult(
           MEDIA_STREAM_REQUEST_PENDING_MEDIA_TRACKS);
     }
     request_it = user_media_requests_.erase(request_it);
   }
 }
 
-MediaStreamImpl::MediaDevicesRequestInfo*
-MediaStreamImpl::FindMediaDevicesRequestInfo(
+UserMediaClientImpl::MediaDevicesRequestInfo*
+UserMediaClientImpl::FindMediaDevicesRequestInfo(
     int request_id) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it)->audio_input_request_id == request_id ||
         (*it)->video_input_request_id == request_id ||
         (*it)->audio_output_request_id == request_id) {
       return (*it);
     }
   }
   return NULL;
 }
 
-MediaStreamImpl::MediaDevicesRequestInfo*
-MediaStreamImpl::FindMediaDevicesRequestInfo(
+UserMediaClientImpl::MediaDevicesRequestInfo*
+UserMediaClientImpl::FindMediaDevicesRequestInfo(
     const blink::WebMediaDevicesRequest& request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it)->request == request)
       return (*it);
   }
   return NULL;
 }
 
-void MediaStreamImpl::CancelAndDeleteMediaDevicesRequest(
+void UserMediaClientImpl::CancelAndDeleteMediaDevicesRequest(
     MediaDevicesRequestInfo* request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it) == request) {
       // Cancel device enumeration.
       media_stream_dispatcher_->StopEnumerateDevices(
           request->audio_input_request_id, weak_factory_.GetWeakPtr());
       media_stream_dispatcher_->StopEnumerateDevices(
           request->video_input_request_id, weak_factory_.GetWeakPtr());
       media_stream_dispatcher_->StopEnumerateDevices(
           request->audio_output_request_id, weak_factory_.GetWeakPtr());
 
       media_devices_requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
-void MediaStreamImpl::FrameWillClose() {
+void UserMediaClientImpl::FrameWillClose() {
   // Cancel all outstanding UserMediaRequests.
   DeleteAllUserMediaRequests();
 
   // Loop through all current local sources and stop the sources.
   LocalStreamSources::iterator sources_it = local_sources_.begin();
   while (sources_it != local_sources_.end()) {
     StopLocalSource(*sources_it, true);
     sources_it = local_sources_.erase(sources_it);
   }
 }
 
-void MediaStreamImpl::OnLocalSourceStopped(
+void UserMediaClientImpl::OnLocalSourceStopped(
     const blink::WebMediaStreamSource& source) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "MediaStreamImpl::OnLocalSourceStopped";
+  DVLOG(1) << "UserMediaClientImpl::OnLocalSourceStopped";
 
   bool device_found = false;
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
     if (device_it->id()  == source.id()) {
       device_found = true;
       local_sources_.erase(device_it);
       break;
     }
   }
   CHECK(device_found);
 
   MediaStreamSource* source_impl =
       static_cast<MediaStreamSource*>(source.extraData());
   media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 }
 
-void MediaStreamImpl::StopLocalSource(
+void UserMediaClientImpl::StopLocalSource(
     const blink::WebMediaStreamSource& source,
     bool notify_dispatcher) {
   MediaStreamSource* source_impl =
       static_cast<MediaStreamSource*>(source.extraData());
-  DVLOG(1) << "MediaStreamImpl::StopLocalSource("
+  DVLOG(1) << "UserMediaClientImpl::StopLocalSource("
            << "{device_id = " << source_impl->device_info().device.id << "})";
 
   if (notify_dispatcher)
     media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 
   source_impl->ResetSourceStoppedCallback();
   source_impl->StopSource();
 }
 
-MediaStreamImpl::UserMediaRequestInfo::UserMediaRequestInfo(
+UserMediaClientImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     const blink::WebUserMediaRequest& request,
     bool enable_automatic_output_device_selection)
     : request_id(request_id),
       generated(false),
       enable_automatic_output_device_selection(
           enable_automatic_output_device_selection),
       request(request),
       request_result_(MEDIA_DEVICE_OK),
       request_result_name_("") {
 }
 
-MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
+UserMediaClientImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
   DVLOG(1) << "~UserMediaRequestInfo";
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::StartAudioTrack(
+void UserMediaClientImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     const blink::WebMediaConstraints& constraints) {
   DCHECK(track.source().type() == blink::WebMediaStreamSource::TypeAudio);
   MediaStreamAudioSource* native_source =
       static_cast <MediaStreamAudioSource*>(track.source().extraData());
   DCHECK(native_source);
 
   sources_.push_back(track.source());
   sources_waiting_for_callback_.push_back(native_source);
   native_source->AddTrack(
       track, constraints, base::Bind(
-          &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted,
+          &UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
           AsWeakPtr()));
 }
 
 blink::WebMediaStreamTrack
-MediaStreamImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
+UserMediaClientImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
     const blink::WebMediaStreamSource& source,
     const blink::WebMediaConstraints& constraints) {
   DCHECK(source.type() == blink::WebMediaStreamSource::TypeVideo);
   MediaStreamVideoSource* native_source =
       MediaStreamVideoSource::GetVideoSource(source);
   DCHECK(native_source);
   sources_.push_back(source);
   sources_waiting_for_callback_.push_back(native_source);
   return MediaStreamVideoTrack::CreateVideoTrack(
       native_source, constraints, base::Bind(
-          &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted,
+          &UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
           AsWeakPtr()),
       true);
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
+void UserMediaClientImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
     const ResourcesReady& callback) {
   DCHECK(ready_callback_.is_null());
   ready_callback_ = callback;
   CheckAllTracksStarted();
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted(
+void UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted(
     MediaStreamSource* source,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DVLOG(1) << "OnTrackStarted result " << result;
   std::vector<MediaStreamSource*>::iterator it =
       std::find(sources_waiting_for_callback_.begin(),
                 sources_waiting_for_callback_.end(),
                 source);
   DCHECK(it != sources_waiting_for_callback_.end());
   sources_waiting_for_callback_.erase(it);
   // All tracks must be started successfully. Otherwise the request is a
   // failure.
   if (result != MEDIA_DEVICE_OK) {
     request_result_ = result;
     request_result_name_ = result_name;
   }
 
   CheckAllTracksStarted();
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
+void UserMediaClientImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
   if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) {
     ready_callback_.Run(this, request_result_, request_result_name_);
   }
 }
 
-bool MediaStreamImpl::UserMediaRequestInfo::IsSourceUsed(
+bool UserMediaClientImpl::UserMediaRequestInfo::IsSourceUsed(
     const blink::WebMediaStreamSource& source) const {
   for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it =
            sources_.begin();
        source_it != sources_.end(); ++source_it) {
     if (source_it->id() == source.id())
       return true;
   }
   return false;
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::RemoveSource(
+void UserMediaClientImpl::UserMediaRequestInfo::RemoveSource(
     const blink::WebMediaStreamSource& source) {
   for (std::vector<blink::WebMediaStreamSource>::iterator it =
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
-bool MediaStreamImpl::UserMediaRequestInfo::HasPendingSources() const {
+bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   return !sources_waiting_for_callback_.empty();
 }
 
 }  // namespace content