Implement Chrome Extension TabCapture API.

chrome/browser/extensions/api/tab_capture/tab_capture_event_router.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/extensions/api/tab_capture/tab_capture_event_router.h"
+
+#include "base/string_number_conversions.h"
+#include "base/string_piece.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_dependency_manager.h"
+#include "chrome/browser/media/media_internals.h"
+#include "chrome/browser/extensions/event_names.h"
+#include "chrome/browser/extensions/event_router.h"
+
+namespace events = extensions::event_names;
+
+namespace extensions {
+
+// TODO(justinlin): This should maybe be filtered/partitioned by extension.
+TabCaptureEventRouter::TabCaptureEventRouter(Profile* profile)
+    : profile_(profile) {
+  MediaInternals::GetInstance()->AddObserver(this);
+}
+
+TabCaptureEventRouter::~TabCaptureEventRouter() {
+  MediaInternals::GetInstance()->RemoveObserver(this);
+}
+
+void TabCaptureEventRouter::OnRequestUpdate(
+    const content::MediaStreamDevice& device,
+    const content::MediaStreamRequest::RequestState new_state) {
+  EventRouter* router = profile_ ? profile_->GetExtensionEventRouter() : NULL;
+  if (!router)
+    return;
+
+  if (device.type != content::MEDIA_TAB_VIDEO_CAPTURE &&
+      device.type != content::MEDIA_TAB_AUDIO_CAPTURE)
+    return;
+
+  // Parse out the tab_id.
+  const size_t sep_pos = device.device_id.find(':');
+  if (sep_pos == std::string::npos)
+    return;
+
+  int tabId = -1;
+  if (!base::StringToInt(
+        base::StringPiece(device.device_id.data(), sep_pos), &tabId))
+    return;
+
+  tab_capture::TabCaptureState state =
+      tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_NONE;
+  switch (new_state) {
+    case content::MediaStreamRequest::STATE_REQUESTED:
+      state = tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_REQUESTED;
+      break;
+    case content::MediaStreamRequest::STATE_PENDING_APPROVAL:
+      state = tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_PENDING;
+      break;
+    case content::MediaStreamRequest::STATE_OPENING:
+      state = tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_ACTIVE;
+      break;
+    case content::MediaStreamRequest::STATE_DONE:
+      state = tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED;
+      break;
+    case content::MediaStreamRequest::STATE_ERROR:
+      state = tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR;
+      break;
+    default:
+      // TODO(justinlin): Implement muted, cancelled state notification.
+      break;
+  }
+
+  if (state == tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_NONE) {
+    VLOG(1) << "Observed an unhandled capture state.";
+    return;
+  }
+
+  scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo());
+  info->tab_id = tabId;
+  info->status = state;
+
+  scoped_ptr<base::ListValue> args(new ListValue());
+  args->Append(info->ToValue().release());
+  router->DispatchEventToRenderers(events::kOnTabCaptured,
+                                   args.Pass(),
+                                   profile_,
+                                   GURL());
+
+  if (state != tab_capture::EXPERIMENTAL_TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR)
+    requests_[tabId] = state;
+  else
+    requests_.erase(tabId);
+}
+
+std::map<int, tab_capture::TabCaptureState>
+  TabCaptureEventRouter::GetCapturedTabs() {
+  return requests_;
+}
+
+}  // namespace extensions