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();
   }
 }
 
 void DisplayConfigurator::SetDelegateForTesting(
@@ skipping 182 matching lines @@
 
 void DisplayConfigurator::QueryContentProtectionStatus(
     ContentProtectionClientId 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,
     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,
     int64_t display_id,
     uint32_t desired_method_mask,
     const EnableProtectionCallback& callback) {
@@ skipping 440 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