Indicate tab recording state in tab strip

chrome/browser/media/media_stream_capture_indicator.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 "chrome/browser/media/media_stream_capture_indicator.h"
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/media_stream_request.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 87 matching lines @@
     const MediaStreamCaptureIndicator::CaptureDeviceTab& tab) {
     return (render_process_id_ == tab.render_process_id &&
             render_view_id_ == tab.render_view_id);
 }
 
 MediaStreamCaptureIndicator::MediaStreamCaptureIndicator()
     : status_icon_(NULL),
       mic_image_(NULL),
       camera_image_(NULL),
       balloon_image_(NULL),
-      request_index_(0) {
+      request_index_(0),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 MediaStreamCaptureIndicator::~MediaStreamCaptureIndicator() {
   // The user is responsible for cleaning up by closing all the opened devices.
   DCHECK(tabs_.empty());
 }
 
 bool MediaStreamCaptureIndicator::IsCommandIdChecked(
     int command_id) const {
   NOTIMPLEMENTED() << "There are no checked items in the MediaStream menu.";
@@ skipping 30 matching lines @@
 void MediaStreamCaptureIndicator::CaptureDevicesOpened(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!devices.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaStreamCaptureIndicator::DoDevicesOpenedOnUIThread,
-                 this, render_process_id, render_view_id, devices));
+                 weak_ptr_factory_.GetWeakPtr(),
+                 render_process_id, render_view_id, devices));
 }
 
 void MediaStreamCaptureIndicator::CaptureDevicesClosed(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!devices.empty());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaStreamCaptureIndicator::DoDevicesClosedOnUIThread,
-                 this, render_process_id, render_view_id, devices));
+                 weak_ptr_factory_.GetWeakPtr(),
+                 render_process_id, render_view_id, devices));
 }
 
 void MediaStreamCaptureIndicator::DoDevicesOpenedOnUIThread(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   CreateStatusTray();
 
-  // If we don't have a status icon or one could not be created successfully,
-  // then no need to continue.
-  if (!status_icon_)
-    return;
-
   AddCaptureDeviceTab(render_process_id, render_view_id, devices);
 }
 
 void MediaStreamCaptureIndicator::DoDevicesClosedOnUIThread(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!status_icon_)
-    return;
 
   RemoveCaptureDeviceTab(render_process_id, render_view_id, devices);
 }
 
 void MediaStreamCaptureIndicator::CreateStatusTray() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (status_icon_)
     return;
 
   // If there is no browser process, we should not create the status tray.
@@ skipping 181 matching lines @@
       ++iter->audio_ref_count;
       audio = true;
     } else if (content::IsVideoMediaType(dev->type)) {
       ++iter->video_ref_count;
       video = true;
     } else {
       NOTIMPLEMENTED();
     }
   }
 
+  WebContents* web_contents = tab_util::GetWebContentsByID(
+      render_process_id, render_view_id);
+  web_contents->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB);
+
+  if (!status_icon_)
+    return;
+
   UpdateStatusTrayIconContextMenu();
 
   ShowBalloon(render_process_id, render_view_id, audio, video);
 }
 
 void MediaStreamCaptureIndicator::RemoveCaptureDeviceTab(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 13 matching lines @@
 
       DCHECK_GE(iter->audio_ref_count, 0);
       DCHECK_GE(iter->video_ref_count, 0);
     }
 
     // Remove the tab if all the devices have been closed.
     if (iter->audio_ref_count == 0 && iter->video_ref_count == 0)
       tabs_.erase(iter);
   }
 
+  if (!status_icon_)
+    return;
+
   UpdateStatusTrayIconContextMenu();
 }
 
+bool MediaStreamCaptureIndicator::IsProcessCapturing(int render_process_id,
+                                                     int render_view_id) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CaptureDeviceTabs::const_iterator iter = std::find_if(
+      tabs_.begin(), tabs_.end(), TabEquals(render_process_id, render_view_id));
+  if (iter == tabs_.end())
+    return false;
+  return (iter->audio_ref_count > 0 || iter->video_ref_count > 0);
+}
+
 void MediaStreamCaptureIndicator::EnsureImageLoadingTracker() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (tracker_.get())
     return;
 
   tracker_.reset(new ImageLoadingTracker(this));
   pending_messages_.clear();
   request_index_ = 0;
 }