PPAPI: Make output protection API work with mus+ash

chrome/browser/chromeos/display/output_protection_delegate.cc

 // 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 "chrome/browser/chromeos/display/output_protection_delegate.h"
 
-#include "ash/shell.h"
-#include "build/build_config.h"
+#include "chrome/browser/chromeos/display/output_protection_controller_ash.h"
+#include "chrome/browser/chromeos/display/output_protection_controller_mus.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/web_contents.h"
+#include "services/service_manager/runner/common/client_util.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/display/types/display_constants.h"
 
 namespace chromeos {
 
 namespace {
 
+bool IsRunningInMash() {
+  return service_manager::ServiceManagerIsRemote();
+}
+
 bool GetCurrentDisplayId(content::RenderFrameHost* rfh, int64_t* display_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(rfh);
   DCHECK(display_id);
 
   display::Screen* screen = display::Screen::GetScreen();
   if (!screen)
     return false;
   display::Display display =
       screen->GetDisplayNearestWindow(rfh->GetNativeView());
   *display_id = display.id();
   return true;
 }
 
 void DoNothing(bool status) {
 }
 
 }  // namespace
 
+OutputProtectionDelegate::Controller::Controller() {}
+
+OutputProtectionDelegate::Controller::~Controller() {}
+
 OutputProtectionDelegate::OutputProtectionDelegate(int render_process_id,
                                                    int render_frame_id)
     : render_process_id_(render_process_id),
       render_frame_id_(render_frame_id),
       window_(nullptr),
-      client_id_(display::DisplayConfigurator::kInvalidClientId),
-      display_id_(0),
+      display_id_(display::kInvalidDisplayId),
       weak_ptr_factory_(this) {
   // This can be constructed on IO or UI thread.
 }
 
 OutputProtectionDelegate::~OutputProtectionDelegate() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
-  display::DisplayConfigurator* configurator =
-      ash::Shell::GetInstance()->display_configurator();
-  configurator->UnregisterContentProtectionClient(client_id_);
-
   if (window_)
     window_->RemoveObserver(this);
 }
 
-display::DisplayConfigurator::ContentProtectionClientId
-OutputProtectionDelegate::GetClientId() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (client_id_ == display::DisplayConfigurator::kInvalidClientId) {
-    content::RenderFrameHost* rfh =
-        content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
-    if (!rfh || !GetCurrentDisplayId(rfh, &display_id_))
-      return display::DisplayConfigurator::kInvalidClientId;
-
-    aura::Window* window = rfh->GetNativeView();
-    if (!window)
-      return display::DisplayConfigurator::kInvalidClientId;
-
-    display::DisplayConfigurator* configurator =
-        ash::Shell::GetInstance()->display_configurator();
-    client_id_ = configurator->RegisterContentProtectionClient();
-
-    if (client_id_ != display::DisplayConfigurator::kInvalidClientId) {
-      window->AddObserver(this);
-      window_ = window;
-    }
-  }
-  return client_id_;
-}
-
 void OutputProtectionDelegate::QueryStatus(
     const QueryStatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  if (!InitializeControllerIfNecessary()) {
+    callback.Run(false, 0, 0);
+    return;
+  }
+
+  controller_->QueryStatus(display_id_, callback);
+}
+
+void OutputProtectionDelegate::SetProtection(
+    uint32_t desired_method_mask,
+    const SetProtectionCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (!InitializeControllerIfNecessary()) {
+    callback.Run(false);
+    return;
+  }
+  controller_->SetProtection(display_id_, desired_method_mask, callback);
+  desired_method_mask_ = desired_method_mask;
+}
+
+bool OutputProtectionDelegate::InitializeControllerIfNecessary() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (controller_)
+    return true;
+
   content::RenderFrameHost* rfh =
       content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
   if (!rfh) {
     LOG(WARNING) << "RenderFrameHost is not alive.";

[dcheng, 2017/02/15 06:26:51]

Nit: DLOG?

[Peng, 2017/02/15 16:15:33]

Done.

-    callback.Run(false, 0, 0);
-    return;
+    return false;
   }
 
-  display::DisplayConfigurator* configurator =
-      ash::Shell::GetInstance()->display_configurator();
-  configurator->QueryContentProtectionStatus(
-      GetClientId(), display_id_,
-      base::Bind(&OutputProtectionDelegate::QueryStatusComplete,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
-}
+  int64_t display_id = display::kInvalidDisplayId;
+  if (!GetCurrentDisplayId(rfh, &display_id))
+    return false;
 
-void OutputProtectionDelegate::EnableProtection(
-    uint32_t desired_method_mask,
-    const EnableProtectionCallback& callback) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  aura::Window* window = rfh->GetNativeView();
+  if (!window)
+    return false;
 
-  display::DisplayConfigurator* configurator =
-      ash::Shell::GetInstance()->display_configurator();
-  configurator->EnableContentProtection(
-      GetClientId(), display_id_, desired_method_mask,
-      base::Bind(&OutputProtectionDelegate::EnableProtectionComplete,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
-  desired_method_mask_ = desired_method_mask;
-}
+  if (IsRunningInMash())
+    controller_ = base::MakeUnique<OutputProtectionControllerMus>();
+  else
+    controller_ = base::MakeUnique<OutputProtectionControllerAsh>();
 
-void OutputProtectionDelegate::QueryStatusComplete(
-    const QueryStatusCallback& callback,
-    const display::DisplayConfigurator::QueryProtectionResponse& response) {
-  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
-  // be removed.
-  if (!rfh) {
-    LOG(WARNING) << "RenderFrameHost is not alive.";
-    callback.Run(false, 0, 0);
-    return;
-  }
-
-  callback.Run(response.success, response.link_mask, response.protection_mask);
-}
-
-void OutputProtectionDelegate::EnableProtectionComplete(
-    const EnableProtectionCallback& callback,
-    bool success) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
-  callback.Run(success);
+  display_id_ = display_id;
+  window_ = window;
+  window_->AddObserver(this);
+  return true;
 }
 
 void OutputProtectionDelegate::OnWindowHierarchyChanged(
     const aura::WindowObserver::HierarchyChangeParams& params) {
   content::RenderFrameHost* rfh =
       content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
   if (!rfh) {
     LOG(WARNING) << "RenderFrameHost is not alive.";
     return;
   }
 
-  int64_t new_display_id = 0;
+  int64_t new_display_id = display::kInvalidDisplayId;
   if (!GetCurrentDisplayId(rfh, &new_display_id))
     return;
+
   if (display_id_ == new_display_id)
     return;
 
   if (desired_method_mask_ != display::CONTENT_PROTECTION_METHOD_NONE) {
-    // Display changed and should enable output protections on new display.
-    display::DisplayConfigurator* configurator =
-        ash::Shell::GetInstance()->display_configurator();
-    configurator->EnableContentProtection(GetClientId(), new_display_id,
-                                          desired_method_mask_,
-                                          base::Bind(&DoNothing));
-    configurator->EnableContentProtection(
-        GetClientId(), display_id_, display::CONTENT_PROTECTION_METHOD_NONE,
-        base::Bind(&DoNothing));
+    DCHECK(controller_);
+    controller_->SetProtection(new_display_id, desired_method_mask_,
+                               base::Bind(&DoNothing));
+    controller_->SetProtection(display_id_,
+                               display::CONTENT_PROTECTION_METHOD_NONE,
+                               base::Bind(&DoNothing));
   }
   display_id_ = new_display_id;
 }
 
 void OutputProtectionDelegate::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(window, window_);
   window_->RemoveObserver(this);
   window_ = nullptr;
 }
 
 }  // namespace chromeos