Support cancellation of request for opening device.

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 "base/message_loop/message_loop_proxy.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "googleurl/src/gurl.h"
 
 namespace content {
 
+// A request is identified by pair (request_id, handler), or ipc_request.
+// There could be multiple clients making requests and each has its own
+// request_id sequence.
+// The ipc_request is garanteed to be unique when it's created in
+// MediaStreamDispatcher.
 struct MediaStreamDispatcher::Request {
   Request(const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
           int request_id,
           int ipc_request)
       : handler(handler),
         request_id(request_id),
         ipc_request(ipc_request) {
   }
+  bool IsThisRequest(
+      int request_id1,
+      const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
+    return (request_id1 == request_id && handler1.get() == handler.get());
+  }
   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
   int request_id;
   int ipc_request;
 };
 
 struct MediaStreamDispatcher::Stream {
   Stream() {}
   ~Stream() {}
   base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
   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() {}
 
+bool MediaStreamDispatcher::EnumerationRequest::IsThisRequest(
+    int request_id1,
+    const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler1) {
+  return (request_id1 == request_id && handler1.get() == handler.get());
+}
+
 MediaStreamDispatcher::EnumerationState::EnumerationState()
     : ipc_id(-1) {
 }
 
 MediaStreamDispatcher::EnumerationState::~EnumerationState() {}
 
 struct MediaStreamDispatcher::EnumerationState::CachedDevices {
   CachedDevices(const std::string& label,
                 const StreamDeviceInfoArray& device_array)
       : label(label),
@@ skipping 21 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::CancelGenerateStream(int request_id) {
+void MediaStreamDispatcher::CancelGenerateStream(
+    int request_id,
+    const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
   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) {
+    if (it->IsThisRequest(request_id, event_handler)) {
+      int ipc_request = it->ipc_request;
       requests_.erase(it);
       Send(new MediaStreamHostMsg_CancelGenerateStream(routing_id(),
-                                                       request_id));
+                                                       ipc_request));
       break;
     }
   }
 }
 
 void MediaStreamDispatcher::StopStream(const std::string& label) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::StopStream"
            << ", {label = " << label << "}";
 
@@ skipping 47 matching lines @@
       request_id, event_handler, &video_enumeration_state_);
 }
 
 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.get() == event_handler.get()) {
+    if (it->IsThisRequest(request_id, event_handler)) {
       requests->erase(it);
       if (requests->empty() && state->cached_devices) {
         // No more request and has a label, try to stop the label
         // and invalidate the state.
         Send(new MediaStreamHostMsg_StopGeneratedStream(
             routing_id(), state->cached_devices->label));
         state->ipc_id = -1;
         state->cached_devices.reset();
       }
       return;
@@ skipping 11 matching lines @@
   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));
 }
 
+void MediaStreamDispatcher::CancelOpenDevice(
+    int request_id,
+    const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
+  CancelGenerateStream(request_id, event_handler);
+}
+
 void MediaStreamDispatcher::CloseDevice(const std::string& label) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "MediaStreamDispatcher::CloseDevice"
            << ", {label = " << label << "}";
 
   StopStream(label);
 }
 
 bool MediaStreamDispatcher::Send(IPC::Message* message) {
   if (!RenderThread::Get()) {
@@ skipping 186 matching lines @@
                                             int index) {
   LabelStreamMap::iterator it = label_stream_map_.find(label);
   if (it == label_stream_map_.end())
     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