Refactor: Make MediaCaptureDevicesDispatcher have pluggable handlers.

chrome/browser/media/permission_bubble_media_access_handler.cc

Index: chrome/browser/media/permission_bubble_media_access_handler.cc
diff --git a/chrome/browser/media/permission_bubble_media_access_handler.cc b/chrome/browser/media/permission_bubble_media_access_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d955e7f5d4b19a07817ea608dc51e05a11f59f2e
--- /dev/null
+++ b/chrome/browser/media/permission_bubble_media_access_handler.cc
@@ -0,0 +1,148 @@
+// Copyright 2015 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/permission_bubble_media_access_handler.h"
+
+#include "base/metrics/field_trial.h"
+#include "chrome/browser/media/media_stream_devices_controller.h"
+#include "chrome/browser/media/media_stream_infobar_delegate.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
+
+#if defined(ENABLE_EXTENSIONS)
+#include "extensions/common/extension.h"
+#endif
+
+using content::BrowserThread;
+
+namespace {

[Sergey Ulanov, 2015/05/07 01:05:48]

nit: empty line after this one

[changbin, 2015/05/22 05:10:58]

Done.

+// A finch experiment to enable the permission bubble for media requests only.
+bool MediaStreamPermissionBubbleExperimentEnabled() {
+  const std::string group =
+      base::FieldTrialList::FindFullName("MediaStreamPermissionBubble");
+  if (group == "enabled")
+    return true;
+
+  return false;
+}
+}  // namespace
+
+PendingAccessRequest::PendingAccessRequest(
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback)
+    : request(request), callback(callback) {
+}
+
+PendingAccessRequest::~PendingAccessRequest() {
+}
+
+PermissionBubbleMediaAccessHandler::PermissionBubbleMediaAccessHandler(
+    RequestsQueues* requests)
+    : pending_requests_(requests) {
+}
+
+PermissionBubbleMediaAccessHandler::~PermissionBubbleMediaAccessHandler() {
+}
+
+bool PermissionBubbleMediaAccessHandler::SupportsRequest(
+    const content::MediaStreamRequest& request,
+    const extensions::Extension* extension) {
+  bool res = request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE ||

[Sergey Ulanov, 2015/05/07 01:05:48]

s/res/result/

+             request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE;
+#if defined(ENABLE_EXTENSIONS)
+  res &= (!extension || (!extension->is_platform_app() &&

[Sergey Ulanov, 2015/05/07 01:05:48]

I don't think you need this check here. ExtensionMediaAccessHandler already
handles this case and it's added in the list of MediaAccessHandlers before
PermissionBubbleMediaAccessHandler

[changbin, 2015/05/22 05:10:58]

I agree with that. While shouldn't we make the code ignorant of the order of
handlers?

+                         !extension->is_media_request_white_listed()));
+#endif
+  return res;
+}
+
+void PermissionBubbleMediaAccessHandler::HandleRequest(
+    content::WebContents* web_contents,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback,
+    const extensions::Extension* extension) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RequestsQueue& queue = (*pending_requests_)[web_contents];
+  queue.push_back(PendingAccessRequest(request, callback));
+
+  // If this is the only request then show the infobar.
+  if (queue.size() == 1)
+    ProcessQueuedAccessRequest(web_contents);
+}
+
+void PermissionBubbleMediaAccessHandler::ProcessQueuedAccessRequest(
+    content::WebContents* web_contents) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  std::map<content::WebContents*, RequestsQueue>::iterator it =
+      pending_requests_->find(web_contents);
+
+  if (it == pending_requests_->end() || it->second.empty()) {
+    // Don't do anything if the tab was closed.
+    return;
+  }
+
+  DCHECK(!it->second.empty());
+
+  if (PermissionBubbleManager::Enabled() ||
+      MediaStreamPermissionBubbleExperimentEnabled()) {
+    scoped_ptr<MediaStreamDevicesController> controller(
+        new MediaStreamDevicesController(
+            web_contents, it->second.front().request,
+            base::Bind(
+                &PermissionBubbleMediaAccessHandler::OnAccessRequestResponse,
+                base::Unretained(this), web_contents)));
+    if (controller->DismissInfoBarAndTakeActionOnSettings())
+      return;
+    PermissionBubbleManager* bubble_manager =
+        PermissionBubbleManager::FromWebContents(web_contents);
+    if (bubble_manager)
+      bubble_manager->AddRequest(controller.release());
+    return;
+  }
+
+  // TODO(gbillock): delete this block and the MediaStreamInfoBarDelegate
+  // when we've transitioned to bubbles. (crbug/337458)
+  MediaStreamInfoBarDelegate::Create(
+      web_contents, it->second.front().request,
+      base::Bind(&PermissionBubbleMediaAccessHandler::OnAccessRequestResponse,
+                 base::Unretained(this), web_contents));
+}
+
+void PermissionBubbleMediaAccessHandler::OnAccessRequestResponse(
+    content::WebContents* web_contents,
+    const content::MediaStreamDevices& devices,
+    content::MediaStreamRequestResult result,
+    scoped_ptr<content::MediaStreamUI> ui) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  std::map<content::WebContents*, RequestsQueue>::iterator it =
+      pending_requests_->find(web_contents);
+  if (it == pending_requests_->end()) {
+    // WebContents has been destroyed. Don't need to do anything.
+    return;
+  }
+
+  RequestsQueue& queue(it->second);
+  if (queue.empty())
+    return;
+
+  content::MediaResponseCallback callback = queue.front().callback;
+  queue.pop_front();
+
+  if (!queue.empty()) {
+    // Post a task to process next queued request. It has to be done
+    // asynchronously to make sure that calling infobar is not destroyed until
+    // after this function returns.
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(
+            &PermissionBubbleMediaAccessHandler::ProcessQueuedAccessRequest,
+            base::Unretained(this), web_contents));
+  }
+
+  callback.Run(devices, result, ui.Pass());
+}