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"
@@ skipping 67 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->request_id == request_id &&
+        it->handler.get() == event_handler.get()) {

[tommi (sloooow) - chröme, 2013/07/03 08:05:12]

is this the right thing to do?  it seems to me that canceling a request with a
specific ID should always cancel that request.
Is it possible perhaps that there be more than one request with the same ID? 
(if so, this needs to be documented)

[wjia(left Chromium), 2013/07/03 17:41:36]

Yes, it's the right thing to do. The request_id is created by each client and
there could be multiple clients, e.g., MediaStreamImpl and
PepperPluginDelegateImpl. Each client should guarantee its request_id is unique
within that handler. 

When MediaStreamDispatcher receives a request, it will map pair (request_id,
handler) to a unique ipc_request. 

+      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 80 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