ScreenCapture for Android phase1, part II

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 <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 96 matching lines @@
   }
 
   bool IsCapturingAudio() const { return audio_ref_count_ > 0; }
   bool IsCapturingVideo() const { return video_ref_count_ > 0; }
   bool IsMirroring() const { return mirroring_ref_count_ > 0; }
 
   std::unique_ptr<content::MediaStreamUI> RegisterMediaStream(
       const content::MediaStreamDevices& devices);
 
   // Increment ref-counts up based on the type of each device provided.
-  void AddDevices(const content::MediaStreamDevices& devices);
+  void AddDevices(const content::MediaStreamDevices& devices,
+                  const base::Closure& close_callback);
 
   // Decrement ref-counts up based on the type of each device provided.
   void RemoveDevices(const content::MediaStreamDevices& devices);
 
+  // Helper to call |stop_callback_|.
+  void NotifyStopped();
+
  private:
   // content::WebContentsObserver overrides.
   void WebContentsDestroyed() override {
     indicator_->UnregisterWebContents(web_contents());
   }
+  bool IsMirroringType(content::MediaStreamType type);
 
   scoped_refptr<MediaStreamCaptureIndicator> indicator_;
   int audio_ref_count_;
   int video_ref_count_;
   int mirroring_ref_count_;
 
+  base::Closure stop_callback_;
   base::WeakPtrFactory<WebContentsDeviceUsage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsDeviceUsage);
 };
 
 // Implements MediaStreamUI interface. Instances of this class are created for
 // each MediaStream and their ownership is passed to MediaStream implementation
 // in the content layer. Each UIDelegate keeps a weak pointer to the
 // corresponding WebContentsDeviceUsage object to deliver updates about state of
 // the stream.
@@ skipping 11 matching lines @@
     if (started_ && device_usage_.get())
       device_usage_->RemoveDevices(devices_);
   }
 
  private:
   // content::MediaStreamUI interface.
   gfx::NativeViewId OnStarted(const base::Closure& close_callback) override {
     DCHECK(!started_);
     started_ = true;
     if (device_usage_.get())
-      device_usage_->AddDevices(devices_);
+      device_usage_->AddDevices(devices_, close_callback);
     return 0;
   }
 
   base::WeakPtr<WebContentsDeviceUsage> device_usage_;
   content::MediaStreamDevices devices_;
   bool started_;
 
   DISALLOW_COPY_AND_ASSIGN(UIDelegate);
 };
 
 std::unique_ptr<content::MediaStreamUI>
 MediaStreamCaptureIndicator::WebContentsDeviceUsage::RegisterMediaStream(
     const content::MediaStreamDevices& devices) {
   return base::WrapUnique(new UIDelegate(weak_factory_.GetWeakPtr(), devices));
 }
 
 void MediaStreamCaptureIndicator::WebContentsDeviceUsage::AddDevices(
-    const content::MediaStreamDevices& devices) {
+    const content::MediaStreamDevices& devices,
+    const base::Closure& close_callback) {
   for (content::MediaStreamDevices::const_iterator it = devices.begin();
        it != devices.end(); ++it) {
-    if (it->type == content::MEDIA_TAB_AUDIO_CAPTURE ||
-        it->type == content::MEDIA_TAB_VIDEO_CAPTURE) {
+    if (IsMirroringType(it->type)) {
       ++mirroring_ref_count_;
     } else if (content::IsAudioInputMediaType(it->type)) {
       ++audio_ref_count_;
     } else if (content::IsVideoMediaType(it->type)) {
       ++video_ref_count_;
     } else {
       NOTIMPLEMENTED();
     }
   }
 
-  if (web_contents())
+  if (web_contents()) {
+    stop_callback_ = close_callback;
     web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB);
+  }
 
   indicator_->UpdateNotificationUserInterface();
 }
 
 void MediaStreamCaptureIndicator::WebContentsDeviceUsage::RemoveDevices(
     const content::MediaStreamDevices& devices) {
   for (content::MediaStreamDevices::const_iterator it = devices.begin();
        it != devices.end(); ++it) {
-    if (it->type == content::MEDIA_TAB_AUDIO_CAPTURE ||
-        it->type == content::MEDIA_TAB_VIDEO_CAPTURE) {
+    if (IsMirroringType(it->type)) {
       --mirroring_ref_count_;
     } else if (content::IsAudioInputMediaType(it->type)) {
       --audio_ref_count_;
     } else if (content::IsVideoMediaType(it->type)) {
       --video_ref_count_;
     } else {
       NOTIMPLEMENTED();
     }
   }
 
   DCHECK_GE(audio_ref_count_, 0);
   DCHECK_GE(video_ref_count_, 0);
   DCHECK_GE(mirroring_ref_count_, 0);
 
   web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB);
   indicator_->UpdateNotificationUserInterface();
 }
 
+void MediaStreamCaptureIndicator::WebContentsDeviceUsage::NotifyStopped() {
+  if (!stop_callback_.is_null()) {
+    base::Closure callback = stop_callback_;
+    stop_callback_.Reset();
+    callback.Run();
+  }
+}
+
+bool MediaStreamCaptureIndicator::WebContentsDeviceUsage::IsMirroringType(
+    content::MediaStreamType type) {
+#if defined(OS_ANDROID)
+  return type == content::MEDIA_TAB_AUDIO_CAPTURE ||
+         type == content::MEDIA_TAB_VIDEO_CAPTURE ||
+         type == content::MEDIA_DESKTOP_VIDEO_CAPTURE;
+#else
+  return type == content::MEDIA_TAB_AUDIO_CAPTURE ||
+         type == content::MEDIA_TAB_VIDEO_CAPTURE;
+#endif
+}
+
 MediaStreamCaptureIndicator::MediaStreamCaptureIndicator()
     : status_icon_(NULL),
       mic_image_(NULL),
       camera_image_(NULL) {
 }
 
 MediaStreamCaptureIndicator::~MediaStreamCaptureIndicator() {
   // The user is responsible for cleaning up by reporting the closure of any
   // opened devices.  However, there exists a race condition at shutdown: The UI
   // thread may be stopped before CaptureDevicesClosed() posts the task to
@@ skipping 53 matching lines @@
 }
 
 bool MediaStreamCaptureIndicator::IsBeingMirrored(
     content::WebContents* web_contents) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   WebContentsDeviceUsage* usage = usage_map_.get(web_contents);
   return usage && usage->IsMirroring();
 }
 
+void MediaStreamCaptureIndicator::NotifyStopped(
+    content::WebContents* web_contents) const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  WebContentsDeviceUsage* usage = usage_map_.get(web_contents);
+  if (usage)
+    usage->NotifyStopped();
+}
+
 void MediaStreamCaptureIndicator::UnregisterWebContents(
     WebContents* web_contents) {
   usage_map_.erase(web_contents);
   UpdateNotificationUserInterface();
 }
 
 void MediaStreamCaptureIndicator::MaybeCreateStatusTrayIcon(bool audio,
                                                             bool video) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 122 matching lines @@
   } else if (audio && !video) {
     message_id = IDS_MEDIA_STREAM_STATUS_TRAY_TEXT_AUDIO_ONLY;
     *image = *mic_image_;
   } else if (!audio && video) {
     message_id = IDS_MEDIA_STREAM_STATUS_TRAY_TEXT_VIDEO_ONLY;
     *image = *camera_image_;
   }
 
   *tool_tip = l10n_util::GetStringUTF16(message_id);
 }