Show camera and microphone status indicators.

chrome/browser/media/media_stream_capture_indicator.h

+// 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.
+
+#ifndef CHROME_BROWSER_MEDIA_MEDIA_STREAM_CAPTURE_INDICATOR_H_
+#define CHROME_BROWSER_MEDIA_MEDIA_STREAM_CAPTURE_INDICATOR_H_
+#pragma once
+
+#include <list>
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "content/public/common/media_stream_request.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/models/simple_menu_model.h"
+
+class StatusIcon;
+class StatusTray;
+
+// This indicator is owned by MediaInternals and deleted when the MediaInternals
+// is deleted.
+class MediaStreamCaptureIndicator
+    : public base::RefCountedThreadSafe<MediaStreamCaptureIndicator>,
+      public ui::SimpleMenuModel::Delegate {
+ public:
+  MediaStreamCaptureIndicator();
+
+  // Overrides from SimpleMenuModel::Delegate implementation.
+  virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
+  virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
+  virtual bool GetAcceleratorForCommandId(
+      int command_id,
+      ui::Accelerator* accelerator) OVERRIDE;
+  virtual void ExecuteCommand(int command_id) OVERRIDE;
+
+  // Called on IO thread when MediaStream opens new capture devices.
+  void CaptureDevicesOpened(int render_process_id,
+                            int render_view_id,
+                            const std::string& url,
+                            const content::MediaStreamDevices& devices);
+
+  // Called on IO thread when the MediaStream closes the opened devices.
+  void CaptureDevicesClosed(int render_process_id,
+                            int render_view_id,
+                            const std::string& url,
+                            const content::MediaStreamDevices& devices);
+
+ private:
+  // Struct to store the usage information of the capture devices.
+  struct CaptureDeviceUser {

[tommi (sloooow) - chröme, 2012/04/30 10:57:07]

Should this struct also include usage count?

[no longer working on chromium, 2012/04/30 13:12:54]

The problem of using the usage count is that we need one audio usage count and
one video usage count. The readability gets worse if we need to maintain two
counters.

Right now we handle the counting in the list, for example:
if one media stream session is using both audio and video, we store two stucts
in the list:
1, render_process_id, render_view_id, url, audio
2, render_process_id, render_view_id, url, video
When building the menu, it only shows one item since both have the same
render_process_id, render_view_id and url.

I know it is a bit duplication on the information for the current solution, but
hope it is not a problem. And it seems to me that the how the UI looks is not
completely decided yet, we may do a follow-up refactoring on this class in the
future. By then we may use counters instead.

+    CaptureDeviceUser(int render_process_id,
+                      int render_view_id,
+                      const std::string& url,
+                      content::MediaStreamDeviceType type)
+        : render_process_id(render_process_id),
+          render_view_id(render_view_id),
+          url(url),
+          type(type) {}
+
+    int render_process_id;
+    int render_view_id;
+    std::string url;

[tommi (sloooow) - chröme, 2012/04/30 10:57:07]

do we really care about the URL (render_view_id should be enough)?  Should this
perhaps be title?

[no longer working on chromium, 2012/04/30 13:12:54]

the URL is used as a friendly message telling the users which page is using the
devices. Can we get the url by the render_view_id?

+    content::MediaStreamDeviceType type;
+  };
+
+  // A private predicate used in std::find_if to find a |CaptureDeviceUser|
+  // which matches the information specified at construction.
+  class UserEquals {
+   public:
+    UserEquals(int render_process_id, int render_view_id,
+               const std::string& url, content::MediaStreamDeviceType type);

[tommi (sloooow) - chröme, 2012/04/30 10:57:07]

is it enough to compare only the render_view_id?

[no longer working on chromium, 2012/04/30 13:12:54]

They are not only for comparison, we need both render_process_id and
render_view_id to get the tab.

+    UserEquals(int render_process_id, int render_view_id,
+               const std::string& url);
+
+    bool operator() (
+        const MediaStreamCaptureIndicator::CaptureDeviceUser& user);
+
+   private:
+     int render_process_id_;
+     int render_view_id_;
+     std::string url_;
+     content::MediaStreamDeviceType type_;
+  };
+
+  friend class base::RefCountedThreadSafe<MediaStreamCaptureIndicator>;
+  virtual ~MediaStreamCaptureIndicator();
+
+  // Called by the public functions, executed on UI thread.
+  void DoDevicesOpenedOnUIThread(int render_process_id,
+                                 int render_view_id,
+                                 const std::string& url,
+                                 const content::MediaStreamDevices& devices);
+  void DoDevicesClosedOnUIThread(int render_process_id,
+                                 int render_view_id,
+                                 const std::string& url,
+                                 const content::MediaStreamDevices& devices);
+
+  // Following functions/variables are executed/accessed only on UI thread.
+  // Creates the status tray if it has not been created.
+  void CreateStatusTray();
+
+  // Makes sure we have done one-time initialization of the |icon_image_|.
+  void EnsureStatusTrayIcon();
+
+  // Triggers a balloon in the corner telling users devices are being used.
+  void ShowBalloon(const std::string& url);
+
+  // Hides the status tray from the desktop.
+  void Hide();
+
+  // Adds the new user to the device usage list.
+  void AddCaptureDeviceUser(int render_process_id,
+                            int render_view_id,
+                            const std::string& url,
+                            const content::MediaStreamDevices& devices);
+
+  // Removes the user from the device usage list.
+  void RemoveCaptureDeviceUser(int render_process_id,
+                               int render_view_id,
+                               const std::string& url,
+                               const content::MediaStreamDevices& devices);
+
+  // Updates the status tray menu with the new device list. This call will be
+  // triggered by both AddCaptureDeviceUser() and RemoveCaptureDeviceUser().
+  void UpdateStatusTrayIconContextMenu();
+
+  // Reference to our status icon - owned by the StatusTray. If null,
+  // the platform doesn't support status icons.
+  StatusIcon* status_icon_;
+
+  // Icon to be displayed on the status tray.
+  SkBitmap icon_image_;
+
+  // A list that contains the usage information of the opened capture devices.
+  typedef std::list<CaptureDeviceUser> CaptureDeviceUserList;

[tommi (sloooow) - chröme, 2012/04/30 10:57:07]

What about having the 'users' list a map between render views and usage info?
Also, I would like to not use the word "user" here because this doesn't have
anything to do with the user.

std::map<int, ActiveCaptureDevices>

[no longer working on chromium, 2012/04/30 13:12:54]

According to my understanding, it is a valid case to have one tab having
multiple media streams with different urls.
If this is true, we may not be able to use a map here since the first parameter
must be unique in the map.

hmm, the struct mainly tells the device usage info, not the device info. What
about changing the names to CaptureDevicesUageInfo add CaptureDevicesUagelist?

+  CaptureDeviceUserList users_;
+};
+
+#endif  // CHROME_BROWSER_MEDIA_MEDIA_STREAM_CAPTURE_INDICATOR_H_