Refactor media permission dispatcher class and create proxy class for non-UI threads.

content/renderer/media/media_permission_dispatcher_proxy.cc

+// 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 "content/renderer/media/media_permission_dispatcher_proxy.h"
+
+#include "base/bind.h"
+#include "base/callback_helpers.h"
+#include "base/location.h"
+#include "base/thread_task_runner_handle.h"
+#include "url/gurl.h"
+
+namespace content {
+
+class MediaPermissionDispatcherProxy::Core {
+ public:
+  Core(scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+       base::WeakPtr<MediaPermissionDispatcherProxy> parent,
+       base::WeakPtr<MediaPermissionDispatcher> media_permission_dispatcher);
+  ~Core();
+
+  void HasPermission(Type type,
+                     const GURL& security_origin,
+                     uint32_t request_id);
+
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner() {
+    return ui_task_runner_;
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner() {
+    return caller_task_runner_;
+  }
+
+ private:
+  // Reports the result on the caller's thread.
+  void ReportResult(uint32_t request_id, bool granted);
+
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
+  base::WeakPtr<MediaPermissionDispatcherProxy> parent_;
+  base::WeakPtr<MediaPermissionDispatcher> media_permission_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+MediaPermissionDispatcherProxy::Core::Core(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    base::WeakPtr<MediaPermissionDispatcherProxy> parent,
+    base::WeakPtr<MediaPermissionDispatcher> media_permission)
+    : ui_task_runner_(ui_task_runner),
+      caller_task_runner_(caller_task_runner),
+      parent_(parent),
+      media_permission_(media_permission) {}
+
+MediaPermissionDispatcherProxy::Core::~Core() {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+}
+
+void MediaPermissionDispatcherProxy::Core::HasPermission(
+    Type type,
+    const GURL& security_origin,
+    uint32_t request_id) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+
+  if (media_permission_.get()) {
+    media_permission_->HasPermission(
+        type, security_origin,
+        base::Bind(&MediaPermissionDispatcherProxy::Core::ReportResult,
+                   base::Unretained(this), request_id));

[perkj_chrome, 2015/09/22 08:24:16]

is this safe?

[guoweis_left_chromium, 2015/09/22 18:48:49]

Done.

+  } else {
+    ReportResult(request_id, false);
+  }
+}
+
+void MediaPermissionDispatcherProxy::Core::ReportResult(uint32_t request_id,
+                                                        bool result) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  caller_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MediaPermissionDispatcherProxy::DeliverResult,
+                            parent_, request_id, result));
+}
+
+MediaPermissionDispatcherProxy::MediaPermissionDispatcherProxy(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    base::WeakPtr<MediaPermissionDispatcher> media_permission) {
+  core_.reset(new Core(ui_task_runner, caller_task_runner,
+                       base::AsWeakPtr(this), media_permission));
+}
+
+MediaPermissionDispatcherProxy::~MediaPermissionDispatcherProxy() {
+  DCHECK(core_->caller_task_runner()->BelongsToCurrentThread());
+
+  auto ui_task_runner = core_->ui_task_runner();
+  ui_task_runner->DeleteSoon(FROM_HERE, core_.release());
+}
+
+void MediaPermissionDispatcherProxy::HasPermission(
+    Type type,
+    const GURL& security_origin,
+    const PermissionStatusCB& permission_status_cb) {
+  DCHECK(core_->caller_task_runner()->BelongsToCurrentThread());
+
+  core_->ui_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Core::HasPermission, base::Unretained(core_.get()), type,

[perkj_chrome, 2015/09/22 08:24:16]

Why is Unretained safe here? Document. 

[guoweis_left_chromium, 2015/09/22 18:48:49]

Done.

+                 security_origin, RegisterCallback(permission_status_cb)));
+}
+
+void MediaPermissionDispatcherProxy::RequestPermission(
+    Type type,
+    const GURL& security_origin,
+    const PermissionStatusCB& permission_status_cb) {
+  DCHECK(core_->caller_task_runner()->BelongsToCurrentThread());
+  NOTREACHED()
+      << "RequestPermission is not supported in MediaPermissionDispatcherProxy";

[perkj_chrome, 2015/09/22 08:24:16]

why not implement this too at the same time? 

[guoweis_left_chromium, 2015/09/22 18:48:49]

I believe further down, this could trigger a prompt and I'd like that to be an
intentional decision.

+  if (!permission_status_cb.is_null())
+    permission_status_cb.Run(false);
+}
+
+}  // namespace content