Move chrome://media-internals to content. This allows us to hide implementation details from the pu…

chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc

Index: chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc
===================================================================
--- chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc	(revision 179909)
+++ chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc	(working copy)
@@ -10,7 +10,6 @@
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/media/media_internals.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/common/chrome_notification_types.h"
@@ -32,76 +31,16 @@
 }
 
 TabCaptureRegistry::TabCaptureRegistry(Profile* profile)
-    : proxy_(new MediaObserverProxy()), profile_(profile) {
-  proxy_->Attach(this);
+    : profile_(profile) {
+  MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 }
 
 TabCaptureRegistry::~TabCaptureRegistry() {
-  proxy_->Detach();
+  MediaCaptureDevicesDispatcher::GetInstance()->RemoveObserver(this);
 }
 
-void TabCaptureRegistry::HandleRequestUpdateOnUIThread(
-    int render_process_id,
-    int render_view_id,
-    const content::MediaStreamDevice& device,
-    const content::MediaRequestState new_state) {
-  EventRouter* router = profile_ ?
-      extensions::ExtensionSystem::Get(profile_)->event_router() : NULL;
-  if (!router)
-    return;
-
-  std::pair<int, int> key = std::make_pair(render_process_id, render_view_id);
-
-  DeviceCaptureRequestMap::iterator request_it = requests_.find(key);
-  if (request_it == requests_.end()) {
-    LOG(ERROR) << "Receiving updates for invalid tab capture request.";
-    return;
-  }
-
-  tab_capture::TabCaptureState state = tab_capture::TAB_CAPTURE_STATE_NONE;
-  switch (new_state) {
-    case content::MEDIA_REQUEST_STATE_REQUESTED:
-      state = tab_capture::TAB_CAPTURE_STATE_REQUESTED;
-      break;
-    case content::MEDIA_REQUEST_STATE_PENDING_APPROVAL:
-      state = tab_capture::TAB_CAPTURE_STATE_PENDING;
-      break;
-    case content::MEDIA_REQUEST_STATE_DONE:
-      state = tab_capture::TAB_CAPTURE_STATE_ACTIVE;
-      break;
-    case content::MEDIA_REQUEST_STATE_CLOSING:
-      state = tab_capture::TAB_CAPTURE_STATE_STOPPED;
-      break;
-    case content::MEDIA_REQUEST_STATE_ERROR:
-      state = tab_capture::TAB_CAPTURE_STATE_ERROR;
-      break;
-    default:
-      // TODO(justinlin): Implement muted state notification.
-      break;
-  }
-
-  if (state == tab_capture::TAB_CAPTURE_STATE_NONE) {
-    // This is a state we don't handle.
-    return;
-  }
-
-  TabCaptureRegistry::TabCaptureRequest* request_info = &request_it->second;
-  request_info->status = state;
-
-  scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo());
-  info->tab_id = request_info->tab_id;
-  info->status = request_info->status;
-
-  scoped_ptr<base::ListValue> args(new ListValue());
-  args->Append(info->ToValue().release());
-  scoped_ptr<Event> event(new Event(
-      events::kOnTabCaptureStatusChanged, args.Pass()));
-  event->restrict_to_profile = profile_;
-  router->DispatchEventToExtension(request_info->extension_id, event.Pass());
-}
-
 const TabCaptureRegistry::CaptureRequestList
     TabCaptureRegistry::GetCapturedTabs(const std::string& extension_id) {
   CaptureRequestList list;
@@ -157,38 +96,12 @@
       render_process_id, render_view_id)) != requests_.end();
 }
 
-void TabCaptureRegistry::MediaObserverProxy::Attach(
-    TabCaptureRegistry* request_handler) {
-  handler_ = request_handler;
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&TabCaptureRegistry::MediaObserverProxy::
-                 RegisterAsMediaObserverOnIOThread, this, false));
-}
-
-void TabCaptureRegistry::MediaObserverProxy::Detach() {
-  handler_ = NULL;
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&TabCaptureRegistry::MediaObserverProxy::
-                 RegisterAsMediaObserverOnIOThread, this, true));
-}
-
-void TabCaptureRegistry::MediaObserverProxy::RegisterAsMediaObserverOnIOThread(
-      bool unregister) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (MediaInternals::GetInstance()) {
-    if (!unregister)
-      MediaInternals::GetInstance()->AddObserver(this);
-    else
-      MediaInternals::GetInstance()->RemoveObserver(this);
-  }
-}
-
-void TabCaptureRegistry::MediaObserverProxy::OnRequestUpdate(
+void TabCaptureRegistry::OnRequestUpdate(
     int render_process_id,
     int render_view_id,
     const content::MediaStreamDevice& device,
     const content::MediaRequestState new_state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // TODO(justinlin): We drop audio device events since they will occur in
   // parallel with the video device events (we would get duplicate events). When
@@ -197,21 +110,59 @@
   if (device.type != content::MEDIA_TAB_VIDEO_CAPTURE)
     return;
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(&TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread,
-          this, render_process_id, render_view_id, device, new_state));
-}
+  EventRouter* router = profile_ ?
+      extensions::ExtensionSystem::Get(profile_)->event_router() : NULL;
+  if (!router)
+    return;
 
-void TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread(
-    int render_process_id,
-    int render_view_id,
-    const content::MediaStreamDevice& device,
-    const content::MediaRequestState new_state) {
-  if (handler_)
-    handler_->HandleRequestUpdateOnUIThread(render_process_id,
-                                            render_view_id,
-                                            device,
-                                            new_state);
+  std::pair<int, int> key = std::make_pair(render_process_id, render_view_id);
+
+  DeviceCaptureRequestMap::iterator request_it = requests_.find(key);
+  if (request_it == requests_.end()) {
+    LOG(ERROR) << "Receiving updates for invalid tab capture request.";
+    return;
+  }
+
+  tab_capture::TabCaptureState state = tab_capture::TAB_CAPTURE_STATE_NONE;
+  switch (new_state) {
+    case content::MEDIA_REQUEST_STATE_REQUESTED:
+      state = tab_capture::TAB_CAPTURE_STATE_REQUESTED;
+      break;
+    case content::MEDIA_REQUEST_STATE_PENDING_APPROVAL:
+      state = tab_capture::TAB_CAPTURE_STATE_PENDING;
+      break;
+    case content::MEDIA_REQUEST_STATE_DONE:
+      state = tab_capture::TAB_CAPTURE_STATE_ACTIVE;
+      break;
+    case content::MEDIA_REQUEST_STATE_CLOSING:
+      state = tab_capture::TAB_CAPTURE_STATE_STOPPED;
+      break;
+    case content::MEDIA_REQUEST_STATE_ERROR:
+      state = tab_capture::TAB_CAPTURE_STATE_ERROR;
+      break;
+    default:

[scherkus (not reviewing), 2013/02/01 02:05:17]

nit: while you're here can you replace the default handler w/ the two missing
enum states from content/public/browser/media_request_state.h ?

MEDIA_REQUEST_STATE_NOT_REQUESTED
MEDIA_REQUEST_STATE_OPENING

I'm a big fan of having the compiler break if you add/remove enums

[jam, 2013/02/01 02:18:22]

These don't have equivalent values int the tab_capture::TabCaptureState enum.
It's not clear to me as someone not familiar with this code what I'd have to do
if I update that idl file, so I'd rather not fix this now

+      // TODO(justinlin): Implement muted state notification.
+      break;
+  }
+
+  if (state == tab_capture::TAB_CAPTURE_STATE_NONE) {
+    // This is a state we don't handle.
+    return;
+  }
+
+  TabCaptureRegistry::TabCaptureRequest* request_info = &request_it->second;
+  request_info->status = state;
+
+  scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo());
+  info->tab_id = request_info->tab_id;
+  info->status = request_info->status;
+
+  scoped_ptr<base::ListValue> args(new ListValue());
+  args->Append(info->ToValue().release());
+  scoped_ptr<Event> event(new Event(
+      events::kOnTabCaptureStatusChanged, args.Pass()));
+  event->restrict_to_profile = profile_;
+  router->DispatchEventToExtension(request_info->extension_id, event.Pass());
 }
 
 }  // namespace extensions