PPAPI: Make output protection API work with mus+ash

ui/display/manager/chromeos/display_configurator.cc

 // Copyright 2014 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 "ui/display/manager/chromeos/display_configurator.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 472 matching lines @@
       weak_ptr_factory_(this) {}
 
 DisplayConfigurator::~DisplayConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
 
   CallAndClearInProgressCallbacks(false);
   CallAndClearQueuedCallbacks(false);
 
   while (!query_protection_callbacks_.empty()) {
-    query_protection_callbacks_.front().Run(QueryProtectionResponse());
+    query_protection_callbacks_.front().Run(false, 0, 0);
     query_protection_callbacks_.pop();
   }
 
-  while (!enable_protection_callbacks_.empty()) {
-    enable_protection_callbacks_.front().Run(false);
-    enable_protection_callbacks_.pop();
+  while (!set_protection_callbacks_.empty()) {
+    set_protection_callbacks_.front().Run(false);
+    set_protection_callbacks_.pop();
   }
 }
 
 void DisplayConfigurator::SetDelegateForTesting(
     std::unique_ptr<NativeDisplayDelegate> display_delegate) {
   DCHECK(!native_display_delegate_);
 
   native_display_delegate_ = std::move(display_delegate);
   configure_display_ = true;
 }
@@ skipping 124 matching lines @@
 
   configuration_task_.reset(new UpdateDisplayConfigurationTask(
       native_display_delegate_.get(), layout_manager_.get(),
       requested_display_state_, requested_power_state_,
       kSetDisplayPowerForceProbe, background_color_argb, true,
       base::Bind(&DisplayConfigurator::OnConfigured,
                  weak_ptr_factory_.GetWeakPtr())));
   configuration_task_->Run();
 }
 
-DisplayConfigurator::ContentProtectionClientId
-DisplayConfigurator::RegisterContentProtectionClient() {
+uint64_t DisplayConfigurator::RegisterContentProtectionClient() {
   if (!configure_display_ || display_externally_controlled_)
-    return kInvalidClientId;
+    return INVALID_CLIENT_ID;
 
   return next_display_protection_client_id_++;
 }
 
 void DisplayConfigurator::UnregisterContentProtectionClient(
-    ContentProtectionClientId client_id) {
+    uint64_t client_id) {
   client_protection_requests_.erase(client_id);
 
   ContentProtections protections;
   for (const auto& requests_pair : client_protection_requests_) {
     for (const auto& protections_pair : requests_pair.second) {
       protections[protections_pair.first] |= protections_pair.second;
     }
   }
 
-  enable_protection_callbacks_.push(base::Bind(&DoNothing));
+  set_protection_callbacks_.push(base::Bind(&DoNothing));
   ApplyContentProtectionTask* task = new ApplyContentProtectionTask(
       layout_manager_.get(), native_display_delegate_.get(), protections,
       base::Bind(&DisplayConfigurator::OnContentProtectionClientUnregistered,
                  weak_ptr_factory_.GetWeakPtr()));
   content_protection_tasks_.push(
       base::Bind(&ApplyContentProtectionTask::Run, base::Owned(task)));
 
   if (content_protection_tasks_.size() == 1)
     content_protection_tasks_.front().Run();
 }
 
 void DisplayConfigurator::OnContentProtectionClientUnregistered(bool success) {
   DCHECK(!content_protection_tasks_.empty());
   content_protection_tasks_.pop();
 
-  DCHECK(!enable_protection_callbacks_.empty());
-  EnableProtectionCallback callback = enable_protection_callbacks_.front();
-  enable_protection_callbacks_.pop();
+  DCHECK(!set_protection_callbacks_.empty());
+  SetProtectionCallback callback = set_protection_callbacks_.front();
+  set_protection_callbacks_.pop();
 
   if (!content_protection_tasks_.empty())
     content_protection_tasks_.front().Run();
 }
 
 void DisplayConfigurator::QueryContentProtectionStatus(
-    ContentProtectionClientId client_id,
+    uint64_t client_id,
     int64_t display_id,
     const QueryProtectionCallback& callback) {
   // Exclude virtual displays so that protected content will not be recaptured
   // through the cast stream.
   for (const DisplaySnapshot* display : cached_displays_) {
     if (display->display_id() == display_id &&
         !IsPhysicalDisplayType(display->type())) {
-      callback.Run(QueryProtectionResponse());
+      callback.Run(false, 0, 0);
       return;
     }
   }
 
   if (!configure_display_ || display_externally_controlled_) {
-    callback.Run(QueryProtectionResponse());
+    callback.Run(false, 0, 0);
     return;
   }
 
   query_protection_callbacks_.push(callback);
   QueryContentProtectionTask* task = new QueryContentProtectionTask(
       layout_manager_.get(), native_display_delegate_.get(), display_id,
       base::Bind(&DisplayConfigurator::OnContentProtectionQueried,
                  weak_ptr_factory_.GetWeakPtr(), client_id, display_id));
   content_protection_tasks_.push(
       base::Bind(&QueryContentProtectionTask::Run, base::Owned(task)));
   if (content_protection_tasks_.size() == 1)
     content_protection_tasks_.front().Run();
 }
 
 void DisplayConfigurator::OnContentProtectionQueried(
-    ContentProtectionClientId client_id,
+    uint64_t client_id,
     int64_t display_id,
     QueryContentProtectionTask::Response task_response) {
-  QueryProtectionResponse response;
-  response.success = task_response.success;
-  response.link_mask = task_response.link_mask;
+  bool success = task_response.success;
+  uint32_t link_mask = task_response.link_mask;
+  uint32_t protection_mask = 0;
 
   // Don't reveal protections requested by other clients.
   ProtectionRequests::iterator it = client_protection_requests_.find(client_id);
-  if (response.success && it != client_protection_requests_.end()) {
+  if (success && it != client_protection_requests_.end()) {
     uint32_t requested_mask = 0;
     if (it->second.find(display_id) != it->second.end())
       requested_mask = it->second[display_id];
-    response.protection_mask =
+    protection_mask =
         task_response.enabled & ~task_response.unfulfilled & requested_mask;
   }
 
   DCHECK(!content_protection_tasks_.empty());
   content_protection_tasks_.pop();
 
   DCHECK(!query_protection_callbacks_.empty());
   QueryProtectionCallback callback = query_protection_callbacks_.front();
   query_protection_callbacks_.pop();
-  callback.Run(response);
+  callback.Run(success, link_mask, protection_mask);
 
   if (!content_protection_tasks_.empty())
     content_protection_tasks_.front().Run();
 }
 
-void DisplayConfigurator::EnableContentProtection(
-    ContentProtectionClientId client_id,
+void DisplayConfigurator::SetContentProtection(
+    uint64_t client_id,
     int64_t display_id,
     uint32_t desired_method_mask,
-    const EnableProtectionCallback& callback) {
+    const SetProtectionCallback& callback) {
   if (!configure_display_ || display_externally_controlled_) {
     callback.Run(false);
     return;
   }
 
   ContentProtections protections;
   for (const auto& requests_pair : client_protection_requests_) {
     for (const auto& protections_pair : requests_pair.second) {
       if (requests_pair.first == client_id &&
           protections_pair.first == display_id)
         continue;
 
       protections[protections_pair.first] |= protections_pair.second;
     }
   }
   protections[display_id] |= desired_method_mask;
 
-  enable_protection_callbacks_.push(callback);
+  set_protection_callbacks_.push(callback);
   ApplyContentProtectionTask* task = new ApplyContentProtectionTask(
       layout_manager_.get(), native_display_delegate_.get(), protections,
-      base::Bind(&DisplayConfigurator::OnContentProtectionEnabled,
+      base::Bind(&DisplayConfigurator::OnSetContentProtectionCompleted,
                  weak_ptr_factory_.GetWeakPtr(), client_id, display_id,
                  desired_method_mask));
   content_protection_tasks_.push(
       base::Bind(&ApplyContentProtectionTask::Run, base::Owned(task)));
   if (content_protection_tasks_.size() == 1)
     content_protection_tasks_.front().Run();
 }
 
-void DisplayConfigurator::OnContentProtectionEnabled(
-    ContentProtectionClientId client_id,
+void DisplayConfigurator::OnSetContentProtectionCompleted(
+    uint64_t client_id,
     int64_t display_id,
     uint32_t desired_method_mask,
     bool success) {
   DCHECK(!content_protection_tasks_.empty());
   content_protection_tasks_.pop();
 
-  DCHECK(!enable_protection_callbacks_.empty());
-  EnableProtectionCallback callback = enable_protection_callbacks_.front();
-  enable_protection_callbacks_.pop();
+  DCHECK(!set_protection_callbacks_.empty());
+  SetProtectionCallback callback = set_protection_callbacks_.front();
+  set_protection_callbacks_.pop();
 
   if (!success) {
     callback.Run(false);
     return;
   }
 
   if (desired_method_mask == CONTENT_PROTECTION_METHOD_NONE) {
     if (client_protection_requests_.find(client_id) !=
         client_protection_requests_.end()) {
       client_protection_requests_[client_id].erase(display_id);
@@ skipping 390 matching lines @@
   last_virtual_display_id_ = max_display_id & 0xff;
 
   return true;
 }
 
 bool DisplayConfigurator::IsDisplayOn() const {
   return current_power_state_ != chromeos::DISPLAY_POWER_ALL_OFF;
 }
 
 }  // namespace display