Fix for closing the desktop sharing notification bar when the shared window is closed

content/browser/renderer_host/media/video_capture_manager.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/browser/renderer_host/media/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 142 matching lines @@
       base::Bind(&VideoCaptureManager::OnOpened, this,
                  device_info.device.type, capture_session_id));
   return capture_session_id;
 }
 
 void VideoCaptureManager::Close(int capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(listener_);
   DVLOG(1) << "VideoCaptureManager::Close, id " << capture_session_id;
 
-  std::map<media::VideoCaptureSessionId, MediaStreamDevice>::iterator
-      session_it = sessions_.find(capture_session_id);
+  SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     NOTREACHED();
     return;
   }
 
   DeviceEntry* const existing_device = GetDeviceEntryForMediaStreamDevice(
       session_it->second);
   if (existing_device) {
     // Remove any client that is still using the session. This is safe to call
     // even if there are no clients using the session.
@@ skipping 130 matching lines @@
   }
   // Run the callback first, as AddClient() may trigger OnFrameInfo().
   done_cb.Run(entry->video_capture_controller->GetWeakPtr());
   entry->video_capture_controller->AddClient(
       client_id, client_handler, client_render_process, session_id, params);
 }
 
 void VideoCaptureManager::StopCaptureForClient(
     VideoCaptureController* controller,
     VideoCaptureControllerID client_id,
-    VideoCaptureControllerEventHandler* client_handler) {
+    VideoCaptureControllerEventHandler* client_handler,
+    bool aborted_due_to_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(controller);
   DCHECK(client_handler);
 
   DeviceEntry* entry = GetDeviceEntryForController(controller);
   if (!entry) {
     NOTREACHED();
     return;
   }
+  if (aborted_due_to_error) {
+    SessionMap::iterator it;
+    for (it = sessions_.begin(); it != sessions_.end(); ++it) {
+      if (it->second.type == entry->stream_type &&
+          it->second.id == entry->id) {
+        listener_->Aborted(it->second.type, it->first);
+        break;
+      }
+    }
+  }
 
   // Detach client from controller.
   media::VideoCaptureSessionId session_id =
       controller->RemoveClient(client_id, client_handler);
   DVLOG(1) << "VideoCaptureManager::StopCaptureForClient, session_id = "
            << session_id;
 
   // If controller has no more clients, delete controller and device.
   DestroyDeviceEntryIfNoClients(entry);
 }
 
 bool VideoCaptureManager::GetDeviceSupportedFormats(
     media::VideoCaptureSessionId capture_session_id,
     media::VideoCaptureFormats* supported_formats) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(supported_formats->empty());
 
-  std::map<media::VideoCaptureSessionId, MediaStreamDevice>::iterator it =
-      sessions_.find(capture_session_id);
+  SessionMap::iterator it = sessions_.find(capture_session_id);
   if (it == sessions_.end())
     return false;
   DVLOG(1) << "GetDeviceSupportedFormats for device: " << it->second.name;
 
   // Return all available formats of the device, regardless its started state.
   DeviceInfo* existing_device =
       FindDeviceInfoById(it->second.id, devices_info_cache_);
   if (existing_device)
     *supported_formats = existing_device->supported_formats;
   return true;
 }
 
 bool VideoCaptureManager::GetDeviceFormatsInUse(
     media::VideoCaptureSessionId capture_session_id,
     media::VideoCaptureFormats* formats_in_use) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(formats_in_use->empty());
 
-  std::map<media::VideoCaptureSessionId, MediaStreamDevice>::iterator it =
-      sessions_.find(capture_session_id);
+  SessionMap::iterator it = sessions_.find(capture_session_id);
   if (it == sessions_.end())
     return false;
   DVLOG(1) << "GetDeviceFormatsInUse for device: " << it->second.name;
 
   // Return the currently in-use format(s) of the device, if it's started.
   DeviceEntry* device_in_use =
       GetDeviceEntryForMediaStreamDevice(it->second);
   if (device_in_use) {
     // Currently only one format-in-use is supported at the VCC level.
     formats_in_use->push_back(
         device_in_use->video_capture_controller->GetVideoCaptureFormat());
   }
   return true;
 }
 
 void VideoCaptureManager::SetDesktopCaptureWindowId(
     media::VideoCaptureSessionId session_id,
     gfx::NativeViewId window_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  std::map<media::VideoCaptureSessionId, MediaStreamDevice>::iterator
-      session_it = sessions_.find(session_id);
+  SessionMap::iterator session_it = sessions_.find(session_id);
   if (session_it == sessions_.end()) {
     device_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &VideoCaptureManager::SaveDesktopCaptureWindowIdOnDeviceThread,
             this,
             session_id,
             window_id));
     return;
   }
@@ skipping 165 matching lines @@
     if (device_info.type == device->stream_type &&
         device_info.id == device->id) {
       return device;
     }
   }
   return NULL;
 }
 
 VideoCaptureManager::DeviceEntry*
 VideoCaptureManager::GetDeviceEntryForController(
-    const VideoCaptureController* controller) {
+    const VideoCaptureController* controller) const {
   // Look up |controller| in |devices_|.
-  for (DeviceEntries::iterator it = devices_.begin();
+  for (DeviceEntries::const_iterator it = devices_.begin();
        it != devices_.end(); ++it) {
     if ((*it)->video_capture_controller.get() == controller) {
       return *it;
     }
   }
   return NULL;
 }
 
 void VideoCaptureManager::DestroyDeviceEntryIfNoClients(DeviceEntry* entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 12 matching lines @@
         FROM_HERE,
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
                    base::Owned(entry)));
   }
 }
 
 VideoCaptureManager::DeviceEntry* VideoCaptureManager::GetOrCreateDeviceEntry(
     media::VideoCaptureSessionId capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  std::map<media::VideoCaptureSessionId, MediaStreamDevice>::iterator
-      session_it = sessions_.find(capture_session_id);
+  SessionMap::iterator session_it = sessions_.find(capture_session_id);
   if (session_it == sessions_.end()) {
     return NULL;
   }
   const MediaStreamDevice& device_info = session_it->second;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   DeviceEntry* const existing_device =
       GetDeviceEntryForMediaStreamDevice(device_info);
   if (existing_device) {
@@ skipping 36 matching lines @@
 void VideoCaptureManager::SaveDesktopCaptureWindowIdOnDeviceThread(
     media::VideoCaptureSessionId session_id,
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
   DCHECK(notification_window_ids_.find(session_id) ==
          notification_window_ids_.end());
   notification_window_ids_[session_id] = window_id;
 }
 
 }  // namespace content