Pepper API implementation for output protection.

chromeos/display/real_output_configurator_delegate.cc

 // Copyright (c) 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 "chromeos/display/real_output_configurator_delegate.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XInput.h>
@@ skipping 12 matching lines @@
 
 namespace chromeos {
 
 namespace {
 
 // DPI measurements.
 const float kMmInInch = 25.4;
 const float kDpi96 = 96.0;
 const float kPixelsToMmScale = kMmInInch / kDpi96;
 
+// Prefixes of output name
+const char kOutputPortName_VGA[] = "VGA";
+const char kOutputPortName_HDMI[] = "HDMI";
+const char kOutputPortName_DVI[] = "DVI";
+const char kOutputPortName_DisplayPort[] = "DP";
+
 bool IsInternalOutput(const XRROutputInfo* output_info) {
   return IsInternalOutputName(std::string(output_info->name));
 }
 
 RRMode GetOutputNativeMode(const XRROutputInfo* output_info) {
   return output_info->nmode > 0 ? output_info->modes[0] : None;
 }
 
 }  // namespace
 
@@ skipping 320 matching lines @@
                        &mode_info.interlaced)) {
       output.mode_infos.insert(std::make_pair(mode, mode_info));
     } else {
       LOG(WARNING) << "Unable to find XRRModeInfo for mode " << mode;
     }
   }
 
   return output;
 }
 
+bool RealOutputConfiguratorDelegate::GetHDCPState(RROutput id,
+                                                  HDCPState* state) {
+  CHECK(screen_) << "Server not grabbed";
+  unsigned char* values = NULL;
+  int actual_format = 0;
+  unsigned long nitems = 0;
+  unsigned long bytes_after = 0;
+  Atom actual_type = None;
+  int success = 0;
+  Atom prop = XInternAtom(display_, "Content Protection", False);
+
+  bool ok = true;
+  success = XRRGetOutputProperty(display_, id, prop, 0, 100, False,
+                                 False, AnyPropertyType, &actual_type,
+                                 &actual_format, &nitems, &bytes_after,
+                                 &values);
+  if (actual_type == None) {
+    LOG(ERROR) << "Property 'Content Protection' does not exist";
+    ok = false;
+  } else if (success == Success && actual_type == XA_ATOM &&
+             actual_format == 32 && nitems == 1) {
+    Atom value = reinterpret_cast<Atom*>(values)[0];
+    if (value == XInternAtom(display_, "Undesired", False)) {
+      *state = HDCP_State_Undesired;
+    } else if (value == XInternAtom(display_, "Desired", False)) {
+      *state = HDCP_State_Desired;
+    } else if (value == XInternAtom(display_, "Enabled", False)) {
+      *state = HDCP_State_Enabled;
+    } else {
+      LOG(ERROR) << "Unknown property value: " << value;
+      ok = false;
+    }
+  } else {
+    LOG(ERROR) << "XRRGetOutputProperty failed";
+    ok = false;
+  }
+  if (values)
+    XFree(values);
+
+  VLOG(3) << "HDCP state: " << ok << "," << *state;
+  return ok;
+}
+
+bool RealOutputConfiguratorDelegate::SetHDCPState(RROutput id,
+                                                  HDCPState state) {
+  CHECK(screen_) << "Server not grabbed";
+  Atom name = XInternAtom(display_, "Content Protection", False);
+  Atom value;
+  switch (state) {
+    case HDCP_State_Undesired:
+      value = XInternAtom(display_, "Undesired", False);
+      break;
+    case HDCP_State_Desired:
+      value = XInternAtom(display_, "Desired", False);
+      break;
+    default:
+      DCHECK(0) << "Invalid HDCP state: " << state;

[DaleCurtis, 2013/09/13 22:08:33]

NOTREACHED() << "blah blah"

[kcwu, 2013/09/16 11:57:37]

Done.

+      NOTREACHED();
+      return false;
+  }
+  unsigned char *data = reinterpret_cast<unsigned char*>(&value);
+  XRRChangeOutputProperty(display_, id, name, XA_ATOM, 32,
+                          PropModeReplace, data, 1);
+  return true;
+}
+
+bool RealOutputConfiguratorDelegate::QueryOutputProtectionLinkType(
+    RROutput id,
+    PP_OutputProtectionLinkType_Private *link_type) {
+  XRROutputInfo* output_info = XRRGetOutputInfo(display_, screen_, id);
+  if (output_info == NULL) {

[DaleCurtis, 2013/09/13 22:08:33]

!output_info

[kcwu, 2013/09/16 11:57:37]

Done.

+    return false;
+  }
+
+  bool ok = true;
+  if (output_info->connection == RR_Connected) {
+    std::string name(output_info->name);
+    if (IsInternalOutput(output_info)) {
+      *link_type = PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_INTERNAL;
+    } else if (name.find(kOutputPortName_VGA) == 0) {
+      *link_type = PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_VGA;
+    } else if (name.find(kOutputPortName_HDMI) == 0) {
+      *link_type = PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_HDMI;
+    } else if (name.find(kOutputPortName_DisplayPort) == 0) {
+      *link_type = PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_DISPLAYPORT;
+    } else {
+      DCHECK(0) << "Unknown link type: " << name;

[DaleCurtis, 2013/09/13 22:08:33]

NOTREACHED() << "blah blah"

[kcwu, 2013/09/16 11:57:37]

No, this may be reached when new link type is invented in the future.

+      ok = false;
+    }
+  } else {
+    *link_type = PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_NONE;
+  }
+  XRRFreeOutputInfo(output_info);
+  return ok;
+}
+
+bool RealOutputConfiguratorDelegate::EnableOutputProtection(
+    const void* client,
+    uint32_t desired_method_mask) {
+  if (desired_method_mask == PP_OUTPUT_PROTECTION_METHOD_PRIVATE_NONE)
+    client_protection_requests_.erase(client);
+  else
+    client_protection_requests_[client] = desired_method_mask;
+
+  uint32_t all_desires = 0;
+  for (ProtectionRequests::const_iterator it =
+           client_protection_requests_.begin();
+       it != client_protection_requests_.end();
+       ++it) {
+    all_desires |= it->second;
+  }
+
+  for (int i = 0; i < screen_->noutput; ++i) {
+    RROutput this_id = screen_->outputs[i];
+    PP_OutputProtectionLinkType_Private type;
+    if (!QueryOutputProtectionLinkType(this_id, &type))
+      return false;
+
+    if ((type & PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_HDMI) ||
+        (type & PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_DISPLAYPORT)) {
+      HDCPState new_desired_state;
+      if (all_desires & PP_OUTPUT_PROTECTION_METHOD_PRIVATE_HDCP) {
+        new_desired_state = HDCP_State_Desired;
+      } else {
+        new_desired_state = HDCP_State_Undesired;
+      }
+      if (!SetHDCPState(this_id, new_desired_state))
+        return false;
+    }
+  }
+  return true;
+}
+
+bool RealOutputConfiguratorDelegate::QueryOutputProtectionStatus(
+    const void* client,
+    uint32_t* link_mask,
+    uint32_t* protection_mask) {
+  uint32_t enabled = 0;
+  uint32_t unfulfiled = 0;

[DaleCurtis, 2013/09/13 22:08:33]

unfulfilled.

[kcwu, 2013/09/16 11:57:37]

Done.

+
+  *link_mask = 0;
+  for (int i = 0; i < screen_->noutput; ++i) {
+    RROutput this_id = screen_->outputs[i];
+    PP_OutputProtectionLinkType_Private type;
+    if (!QueryOutputProtectionLinkType(this_id, &type))
+      return false;
+    *link_mask |= type;
+
+    if ((type & PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_HDMI) ||
+        (type & PP_OUTPUT_PROTECTION_LINK_TYPE_PRIVATE_DISPLAYPORT)) {
+      HDCPState state;
+      RROutput this_id = screen_->outputs[i];
+      if (!GetHDCPState(this_id, &state))
+        return false;
+      if (state == HDCP_State_Enabled)
+        enabled |= PP_OUTPUT_PROTECTION_METHOD_PRIVATE_HDCP;
+      else
+        unfulfiled |= PP_OUTPUT_PROTECTION_METHOD_PRIVATE_HDCP;
+    }
+  }
+
+  // Don't reveal protections requested by other clients.
+  ProtectionRequests::iterator it = client_protection_requests_.find(client);
+  if (it != client_protection_requests_.end()) {
+    uint32_t requested_mask = it->second;
+    *protection_mask = enabled & ~unfulfiled & requested_mask;
+  } else {
+    *protection_mask = 0;
+  }
+  return true;
+}
+
 void RealOutputConfiguratorDelegate::DestroyUnusedCrtcs(
     const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
   CHECK(screen_) << "Server not grabbed";
   // Setting the screen size will fail if any CRTC doesn't fit afterwards.
   // At the same time, turning CRTCs off and back on uses up a lot of time.
   // This function tries to be smart to avoid too many off/on cycles:
   // - We disable all the CRTCs we won't need after the FB resize.
   // - We set the new modes on CRTCs, if they fit in both the old and new
   //   FBs, and park them at (0,0)
   // - We disable the CRTCs we will need but don't fit in the old FB. Those
@@ skipping 255 matching lines @@
                 << (*outputs)[i].touch_device_id << " to output #" << i;
         break;
       }
     }
   }
 
   XIFreeDeviceInfo(info);
 }
 
 }  // namespace chromeos