[1/8] Prepare Pepper for async output protection configuration

ui/display/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/chromeos/display_configurator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
@@ skipping 604 matching lines @@
   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;
     }
   }
 
   ApplyProtections(protections);
 }
 
-bool DisplayConfigurator::QueryContentProtectionStatus(
+void DisplayConfigurator::QueryContentProtectionStatus(
     ContentProtectionClientId client_id,
     int64_t display_id,
-    uint32_t* link_mask,
-    uint32_t* protection_mask) {
-  if (!configure_display_ || display_externally_controlled_)
-    return false;
+    const QueryProtectionCallback& callback) {
+  QueryProtectionResponse response;
+  if (!configure_display_ || display_externally_controlled_) {
+    callback.Run(response);
+    return;
+  }
 
   uint32_t enabled = 0;
   uint32_t unfulfilled = 0;
-  *link_mask = 0;
+  uint32_t link_mask = 0;
   for (const DisplaySnapshot* display : cached_displays_) {
     // Query display if it is in mirror mode or client on the same display.
     if (!IsMirroring() && display->display_id() != display_id)
       continue;
 
-    *link_mask |= display->type();
+    link_mask |= display->type();
     switch (display->type()) {
       case DISPLAY_CONNECTION_TYPE_UNKNOWN:
-        return false;
+        callback.Run(response);
+        return;
       // DisplayPort, DVI, and HDMI all support HDCP.
       case DISPLAY_CONNECTION_TYPE_DISPLAYPORT:
       case DISPLAY_CONNECTION_TYPE_DVI:
       case DISPLAY_CONNECTION_TYPE_HDMI: {
         HDCPState state;
-        if (!native_display_delegate_->GetHDCPState(*display, &state))
-          return false;
+        if (!native_display_delegate_->GetHDCPState(*display, &state)) {
+          callback.Run(response);
+          return;
+        }
+
         if (state == HDCP_STATE_ENABLED)
           enabled |= CONTENT_PROTECTION_METHOD_HDCP;
         else
           unfulfilled |= CONTENT_PROTECTION_METHOD_HDCP;
         break;
       }
       case DISPLAY_CONNECTION_TYPE_INTERNAL:
       case DISPLAY_CONNECTION_TYPE_VGA:
       case DISPLAY_CONNECTION_TYPE_NETWORK:
         // No protections for these types. Do nothing.
         break;
       case DISPLAY_CONNECTION_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   // Don't reveal protections requested by other clients.
   ProtectionRequests::iterator it = client_protection_requests_.find(client_id);
   if (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];
-    *protection_mask = enabled & ~unfulfilled & requested_mask;
-  } else {
-    *protection_mask = 0;
+    response.protection_mask = enabled & ~unfulfilled & requested_mask;
   }
-  return true;
+
+  response.success = true;
+  response.link_mask = link_mask;
+  callback.Run(response);
 }
 
-bool DisplayConfigurator::EnableContentProtection(
+void DisplayConfigurator::EnableContentProtection(
     ContentProtectionClientId client_id,
     int64_t display_id,
-    uint32_t desired_method_mask) {
-  if (!configure_display_ || display_externally_controlled_)
-    return false;
+    uint32_t desired_method_mask,
+    const EnableProtectionCallback& 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;
 
-  if (!ApplyProtections(protections))
-    return false;
+  if (!ApplyProtections(protections)) {
+    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);
       if (client_protection_requests_[client_id].size() == 0)
         client_protection_requests_.erase(client_id);
     }
   } else {
     client_protection_requests_[client_id][display_id] = desired_method_mask;
   }
 
-  return true;
+  callback.Run(true);
 }
 
 std::vector<ui::ColorCalibrationProfile>
 DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDisplayColorCalibration)) {
     for (const DisplaySnapshot* display : cached_displays_) {
       if (display->display_id() == display_id) {
         return native_display_delegate_->GetAvailableColorCalibrationProfiles(
             *display);
@@ skipping 275 matching lines @@
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_displays_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(cached_displays_,
                                                         attempted_state));
   }
 }
 
 }  // namespace ui