media: Add OutputProtectionProxy

chrome/browser/media/output_protection_proxy.cc

Index: chrome/browser/media/output_protection_proxy.cc
diff --git a/chrome/browser/media/output_protection_proxy.cc b/chrome/browser/media/output_protection_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..04afb394e523df08e6b88ad53aeb1261f9a8ba4b
--- /dev/null
+++ b/chrome/browser/media/output_protection_proxy.cc
@@ -0,0 +1,89 @@
+// Copyright 2016 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/output_protection_proxy.h"
+
+#include "build/build_config.h"
+#include "chrome/browser/media/media_capture_devices_dispatcher.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+#include "ui/display/types/display_constants.h"
+
+namespace chrome {
+
+OutputProtectionProxy::OutputProtectionProxy(int render_process_id,
+                                             int render_frame_id)
+    : render_process_id_(render_process_id),
+      render_frame_id_(render_frame_id),
+#if defined(OS_CHROMEOS)
+      output_protection_delegate_(render_process_id, render_frame_id),
+#endif  // defined(OS_CHROMEOS)
+      weak_ptr_factory_(this) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+}
+
+OutputProtectionProxy::~OutputProtectionProxy() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
+
+void OutputProtectionProxy::QueryStatus(const QueryStatusCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+#if defined(OS_CHROMEOS)
+  output_protection_delegate_.QueryStatus(
+      base::Bind(&OutputProtectionProxy::ProcessQueryStatusResult,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+#else  // defined(OS_CHROMEOS)
+  ProcessQueryStatusResult(callback, true, 0, 0);
+#endif  // defined(OS_CHROMEOS)
+}
+
+void OutputProtectionProxy::EnableProtection(
+    uint32_t desired_method_mask,
+    const EnableProtectionCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+#if defined(OS_CHROMEOS)
+  output_protection_delegate_.EnableProtection(desired_method_mask, callback);
+#else   // defined(OS_CHROMEOS)
+  NOTIMPLEMENTED();
+  callback.Run(false);
+#endif  // defined(OS_CHROMEOS)
+}
+
+void OutputProtectionProxy::ProcessQueryStatusResult(
+    const QueryStatusCallback& callback,
+    bool success,
+    uint32_t link_mask,
+    uint32_t protection_mask) {
+  DVLOG(1) << __FUNCTION__ << ": " << success << ", " << link_mask;
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  content::RenderFrameHost* rfh =
+      content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
+  // TODO(xjz): Investigate whether this check (and the other one above) should

[ddorwin, 2016/06/23 21:36:35]

You removed the one above per jrummell's comment. Are you sure that is okay? If
so, update this comment.

[xhwang, 2016/06/23 21:52:35]

Yeah, this class is just a proxy, output_protection_delegate_ will still check
this.

Updated comment.

+  // be removed.
+  if (!rfh) {
+    LOG(WARNING) << "RenderFrameHost is not alive.";
+    callback.Run(false, 0, 0);
+    return;
+  }
+
+  uint32_t new_link_mask = link_mask;
+  // If we successfully retrieved the device level status, check for capturers.
+  if (success) {
+    const bool is_insecure_capture_detected =
+        MediaCaptureDevicesDispatcher::GetInstance()
+            ->IsInsecureCapturingInProgress(render_process_id_,
+                                            render_frame_id_);
+    if (is_insecure_capture_detected)
+      new_link_mask |= ui::DISPLAY_CONNECTION_TYPE_NETWORK;
+  }
+
+  callback.Run(success, new_link_mask, protection_mask);
+}
+
+}  // namespace chrome