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>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
 
 #include <cmath>
 #include <set>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/message_loop/message_pump_x11.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/display/output_util.h"
+#include "ui/base/x/x11_error_tracker.h"
 
 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 kOutputName_VGA[] = "VGA";
+const char kOutputName_HDMI[] = "HDMI";
+const char kOutputName_DVI[] = "DVI";
+const char kOutputName_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 256 matching lines @@
     OutputConfigurator::ModeInfo mode_info;
     if (InitModeInfo(mode, &mode_info))
       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);

[Daniel Erat, 2013/09/20 15:00:24]

please move this to a constant at the top of the file (e.g.
kContentProtectionAtomName) that you can share across other methods and error
messages

[kcwu, 2013/09/20 20:29:30]

Done.

+
+  bool ok = true;
+  // TODO(kcwu): Move this to x11_util (similar method calls in this file and
+  // output_util.cc)
+  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)) {

[Daniel Erat, 2013/09/20 15:00:24]

please make constants for these too so they aren't duplicated

[kcwu, 2013/09/20 20:29:30]

Done.

+      *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;

[Daniel Erat, 2013/09/20 15:00:24]

nit: mind changing this to "Unknown " << kContentProtectionAtomName << " value:
" so it's obvious what this is referring to if it shows up in the logs?

[kcwu, 2013/09/20 20:29:30]

Done.

+      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:
+      NOTREACHED() << "Invalid HDCP state: " << state;
+      return false;
+  }
+  ui::X11ErrorTracker err_tracker;
+  unsigned char *data = reinterpret_cast<unsigned char*>(&value);
+  XRRChangeOutputProperty(display_, id, name, XA_ATOM, 32,
+                          PropModeReplace, data, 1);
+  if (err_tracker.FoundNewError()) {
+    LOG(ERROR) << "XRRChangeOutputProperty failed";
+    return false;
+  } else {
+    return true;
+  }
+}
+
+bool RealOutputConfiguratorDelegate::QueryOutputProtectionLinkType(
+    RROutput id,
+    OutputType *link_type) {
+  XRROutputInfo* output_info = XRRGetOutputInfo(display_, screen_, id);
+  if (!output_info) {
+    return false;
+  }
+
+  bool ok = true;
+  if (output_info->connection == RR_Connected) {
+    std::string name(output_info->name);
+    if (IsInternalOutput(output_info)) {
+      *link_type = OUTPUT_TYPE_INTERNAL;
+    } else if (name.find(kOutputName_VGA) == 0) {
+      *link_type = OUTPUT_TYPE_VGA;
+    } else if (name.find(kOutputName_HDMI) == 0) {
+      *link_type = OUTPUT_TYPE_HDMI;
+    } else if (name.find(kOutputName_DVI) == 0) {
+      *link_type = OUTPUT_TYPE_DVI;
+    } else if (name.find(kOutputName_DisplayPort) == 0) {
+      *link_type = OUTPUT_TYPE_DISPLAYPORT;
+    } else {
+      DCHECK(0) << "Unknown link type: " << name;

[Daniel Erat, 2013/09/20 15:00:24]

use NOTREACHED() or maybe just LOG(ERROR) instead of DCHECK(0)

[kcwu, 2013/09/20 20:29:30]

Done.

+      ok = false;
+    }
+  } else {
+    *link_type = OUTPUT_TYPE_NONE;
+  }
+  XRRFreeOutputInfo(output_info);
+  return ok;
+}
+
+bool RealOutputConfiguratorDelegate::EnableOutputProtection(
+    chromeos::OutputConfigurator::OutputProtectionClientId client_id,
+    uint32_t desired_method_mask) {
+  if (desired_method_mask == OUTPUT_PROTECTION_METHOD_NONE)
+    client_protection_requests_.erase(client_id);
+  else
+    client_protection_requests_[client_id] = desired_method_mask;

[Daniel Erat, 2013/09/20 15:00:24]

should you hold off on updating the request map until the state has been
successfully set?

[kcwu, 2013/09/20 20:29:30]

Done.

+
+  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];
+    OutputType type;
+    if (!QueryOutputProtectionLinkType(this_id, &type))
+      return false;
+
+    if ((type & OUTPUT_TYPE_HDMI) ||
+        (type & OUTPUT_TYPE_DISPLAYPORT)) {
+      HDCPState new_desired_state;

[Daniel Erat, 2013/09/20 15:00:24]

nit:

  HDCPState new_desired_state =
      (all_desires & OUTPUT_PROTECTION_METHOD_HDCP) ?
      HDCP_STATE_DESIRED : HDCP_STATE_UNDESIRED;

[kcwu, 2013/09/20 20:29:30]

Done.

+      if (all_desires & OUTPUT_PROTECTION_METHOD_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(
+    chromeos::OutputConfigurator::OutputProtectionClientId client_id,
+    uint32_t* link_mask,
+    uint32_t* protection_mask) {

[Daniel Erat, 2013/09/20 15:00:24]

mind adding a CHECK(screen_) here too?

but this seems fishy to me: OutputConfigurator::QueryOutputProtectionStatus()
isn't grabbing the server and fetching the xrandr resources now (which is a good
thing if this gets called while the user is interacting with the browser, since
that'd block the UI thread), but this method uses |screen_|. am i missing
something?

[Daniel Erat, 2013/09/20 15:08:26]

moreover, is there any reason why you can't save the output type (and maybe also
the protection methods?) in the OutputSnapshot structs that are cached by
OutputConfigurator? that would probably let you move some code out of the
delegate and write tests for it in output_configurator_unittest.cc.

[kcwu, 2013/09/20 20:29:30]

I'm confused. marcheu said grabbing is not strictly required. Does that mean I
can cache screen_->outputs first and call XRRGetOutputProperty without grabbing
later?
Before that, I added grab back.

[kcwu, 2013/09/20 20:29:30]

Ah, I didn't notice OutputSnapshot was added recently.
I will use it later today.

[Daniel Erat, 2013/09/20 20:40:59]

screen_ is only valid while the server is grabbed (in fact, it's NULL the rest
of the time). i think that stephane meant that it's okay for you to call
XRRGetOutputProperty() while the server isn't grabbed if you already know the
RROutput that you're interested in.

OutputSnapshot contains the output's RROutput, but it's probably cleaner to just
save the output type to the OutputSnapshot in InitOutputSnapshot(). that way,
it'll already be available from OutputConfigurator::cached_outputs_. if the HDCP
state is cached too, you may not need to communicate with the X server at all to
return the protection status.

[kcwu, 2013/09/23 18:00:02]

Done.

+  uint32_t enabled = 0;
+  uint32_t unfulfilled = 0;
+
+  *link_mask = 0;
+  for (int i = 0; i < screen_->noutput; ++i) {
+    RROutput this_id = screen_->outputs[i];
+    OutputType type;
+    if (!QueryOutputProtectionLinkType(this_id, &type))
+      return false;
+    *link_mask |= type;
+
+    if ((type & OUTPUT_TYPE_HDMI) ||
+        (type & OUTPUT_TYPE_DISPLAYPORT)) {
+      HDCPState state;
+      RROutput this_id = screen_->outputs[i];

[Daniel Erat, 2013/09/20 15:00:24]

i think you're shadowing the earlier |this_id| variable, which should already
have the same value

[kcwu, 2013/09/20 20:29:30]

Done.

+      if (!GetHDCPState(this_id, &state))
+        return false;
+      if (state == HDCP_STATE_ENABLED)
+        enabled |= OUTPUT_PROTECTION_METHOD_HDCP;
+      else
+        unfulfilled |= OUTPUT_PROTECTION_METHOD_HDCP;
+    }
+  }
+
+  // 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 = it->second;
+    *protection_mask = enabled & ~unfulfilled & 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 181 matching lines @@
                 << (*outputs)[i].touch_device_id << " to output #" << i;
         break;
       }
     }
   }
 
   XIFreeDeviceInfo(info);
 }
 
 }  // namespace chromeos