Begin adding support for tab mirroring via the MediaStream audio/video capturing

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 63 matching lines @@
   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));
 }
 
+void MediaStreamDispatcher::GenerateStreamForDevice(
+    int request_id,
+    const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
+    media_stream::StreamOptions components,
+    const std::string& device_id,
+    const GURL& security_origin) {
+  DCHECK(main_loop_->BelongsToCurrentThread());
+  DVLOG(1) << "MediaStreamDispatcher::GenerateStreamForDevice("
+           << request_id << ")";
+
+  requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+  Send(new MediaStreamHostMsg_GenerateStreamForDevice(routing_id(),
+                                                      next_ipc_id_++,
+                                                      components,
+                                                      device_id,
+                                                      security_origin));
+}
+
 void MediaStreamDispatcher::CancelGenerateStream(int request_id) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::CancelGenerateStream"
            << ", {request_id = " << request_id << "}";
 
   RequestList::iterator it = requests_.begin();
   for (; it != requests_.end(); ++it) {
     Request& request = *it;
     if (request.request_id == request_id) {
       requests_.erase(it);
@@ skipping 16 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_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ||
-         type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
+  DCHECK_LT(content::MEDIA_NO_SERVICE, type);
+  DCHECK_GT(content::NUM_MEDIA_TYPES, type);

[wjia(left Chromium), 2012/09/07 17:16:30]

For now, EnumerateDevices are still restricted to either MEDIA_VIDEO_DEVICE_TYPE
or MEDIA_VIDEO_DEVICE_TYPE. In the future, if you need use this API, you can
extend it to other types.

[miu, 2012/09/07 23:14:28]

Done.  Also, reverted EnumerateDevices/StopEnumerateDevices/onDevicesEnumerated
changes.

   DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
            << request_id << ")";
 
-  EnumerationState* state =
-      (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ?
-       &audio_enumeration_state_ : &video_enumeration_state_);
-  state->requests.push_back(
-      EnumerationRequest(event_handler, request_id));
+  EnumerationState& state = enumeration_state_[type];
+  state.requests.push_back(EnumerationRequest(event_handler, request_id));
 
-  if (state->cached_devices.get()) {
+  if (state.cached_devices.get()) {
     event_handler->OnDevicesEnumerated(
-        request_id, state->cached_devices->devices);
-  } else if (state->ipc_id < 0) {
+        request_id, state.cached_devices->devices);
+  } else if (state.ipc_id < 0) {
     Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
                                                  next_ipc_id_,
                                                  type,
                                                  security_origin));
-    state->ipc_id = next_ipc_id_++;
+    state.ipc_id = next_ipc_id_++;
   }
 }
 
 void MediaStreamDispatcher::StopEnumerateDevices(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::StopEnumerateDevices("
            << request_id << ")";
 
   // Remove the request.
-  RemoveEnumerationRequest(
-      request_id, event_handler, &audio_enumeration_state_);
-  RemoveEnumerationRequest(
-      request_id, event_handler, &video_enumeration_state_);
+  for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
+       ++i) {
+    RemoveEnumerationRequest(request_id, event_handler, &enumeration_state_[i]);
+  }
 }
 
 void MediaStreamDispatcher::RemoveEnumerationRequest(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     EnumerationState* state) {
   EnumerationRequestList* requests = &state->requests;
   for (EnumerationRequestList::iterator it = requests->begin();
        it != requests->end(); ++it) {
     if (it->request_id == request_id && it->handler == event_handler) {
@@ skipping 137 matching lines @@
     it->second.handler->OnAudioDeviceFailed(label, index);
 }
 
 void MediaStreamDispatcher::OnDevicesEnumerated(
     int request_id,
     const std::string& label,
     const media_stream::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 {
+  EnumerationState* state = NULL;
+  for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
+       ++i) {
+    if (request_id == enumeration_state_[i].ipc_id) {
+      state = &enumeration_state_[i];
+      break;
+    }
+  }
+  if (state == NULL) {
     // This could happen when requester has stopped enumeration while some
     // enumerated response is on the way. Have to stop the |label| because
     // this might be the first enumerated device list is received. This also
     // lead to same label being stopped multiple times.
     Send(new MediaStreamHostMsg_StopGeneratedStream(routing_id(), label));
     return;
   }
 
   DCHECK(!label.empty());
   state->cached_devices.reset(new EnumerationState::CachedDevices(
@@ skipping 30 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 (device_info.stream_type ==
-              content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) {
+      if (content::IsAudioMediaType(device_info.stream_type)) {
+        new_stream.audio_array.push_back(device_info);
+      } else if (content::IsVideoMediaType(device_info.stream_type)) {
         new_stream.video_array.push_back(device_info);
       } else {
-        new_stream.audio_array.push_back(device_info);
+        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 << ")";
       }
       requests_.erase(it);
       break;
@@ skipping 34 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;
 }