Extend content::DesktopMediaID to allow Aura windows as capture sources.

content/public/browser/desktop_media_id.cc

Index: content/public/browser/desktop_media_id.cc
diff --git a/content/public/browser/desktop_media_id.cc b/content/public/browser/desktop_media_id.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3e5a75ad2e3662a9d2bab93d92ab7e84dbb14088
--- /dev/null
+++ b/content/public/browser/desktop_media_id.cc
@@ -0,0 +1,136 @@
+// Copyright 2013 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/public/browser/desktop_media_id.h"
+
+#include <vector>
+
+#include "base/memory/singleton.h"
+#include "base/strings/string_split.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_observer.h"
+
+namespace  {
+
+class AuraWindowRegistry : public aura::WindowObserver {
+ public:
+  static AuraWindowRegistry* GetInstance() {
+    return Singleton<AuraWindowRegistry>::get();
+  }
+
+  int RegisterWindow(aura::Window* window) {
+    // First check if an Id is already assigned to the |window|.
+    std::map<aura::Window*, int>::iterator it = window_to_id_map_.find(window);
+    if (it != window_to_id_map_.end()) {
+      return it->second;
+    }
+
+    // If the windows doesn't have an Id yet assign it.
+    int id = next_id_++;
+    window_to_id_map_[window] = id;
+    id_to_window_map_[id] = window;
+    window->AddObserver(this);
+    return id;
+  }
+
+  aura::Window* GetWindowById(int id) {
+    std::map<int, aura::Window*>::iterator it = id_to_window_map_.find(id);
+    return (it != id_to_window_map_.end()) ? it->second : NULL;
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<AuraWindowRegistry>;
+
+  AuraWindowRegistry()
+      : next_id_(0) {
+  }
+  ~AuraWindowRegistry() {}
+
+  // WindowObserver overrides.
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+    std::map<aura::Window*, int>::iterator it = window_to_id_map_.find(window);
+    DCHECK(it != window_to_id_map_.end());
+    id_to_window_map_.erase(it->second);
+    window_to_id_map_.erase(it);
+  }
+
+  int next_id_;
+  std::map<aura::Window*, int> window_to_id_map_;
+  std::map<int, aura::Window*> id_to_window_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(AuraWindowRegistry);
+};
+
+}  // namespace
+
+namespace content {
+
+const char kScreenPrefix[] = "screen";
+const char kWindowPrefix[] = "window";
+const char kAuraWindowPrefix[] = "aura_window";
+
+// static
+DesktopMediaID DesktopMediaID::RegisterAuraWindow(aura::Window* window) {
+  return DesktopMediaID(
+      TYPE_AURA_WINDOW,
+      AuraWindowRegistry::GetInstance()->RegisterWindow(window));
+}
+
+// static
+aura::Window* DesktopMediaID::GetAuraWindowById(const DesktopMediaID& id) {
+  DCHECK_EQ(id.type, TYPE_AURA_WINDOW);
+  return AuraWindowRegistry::GetInstance()->GetWindowById(id.id);
+}
+
+// static
+DesktopMediaID DesktopMediaID::Parse(const std::string& str) {
+  std::vector<std::string> parts;
+  base::SplitString(str, ':', &parts);
+
+  if (parts.size() != 2)
+    return DesktopMediaID(TYPE_NONE, 0);
+
+  Type type = TYPE_NONE;
+  if (parts[0] == kScreenPrefix) {
+    type = TYPE_SCREEN;
+  } else if (parts[0] == kWindowPrefix) {
+    type = TYPE_WINDOW;
+  } else if (parts[0] == kAuraWindowPrefix) {
+    type = TYPE_AURA_WINDOW;
+  } else {
+    return DesktopMediaID(TYPE_NONE, 0);
+  }
+
+  int64 id;
+  if (!base::StringToInt64(parts[1], &id))
+    return DesktopMediaID(TYPE_NONE, 0);
+
+  return DesktopMediaID(type, id);
+}
+
+std::string DesktopMediaID::ToString() {
+  std::string prefix;
+  switch (type) {
+    case TYPE_NONE:
+      NOTREACHED();
+      return std::string();
+    case TYPE_SCREEN:
+      prefix = kScreenPrefix;
+      break;
+    case TYPE_WINDOW:
+      prefix = kWindowPrefix;
+      break;
+    case TYPE_AURA_WINDOW:
+      prefix = kAuraWindowPrefix;
+      break;
+  }
+  DCHECK(!prefix.empty());
+
+  prefix.append(":");
+  prefix.append(base::Int64ToString(id));
+
+  return prefix;
+}
+
+}  // namespace content