Pepper API implementation for output protection.

chromeos/display/output_configurator.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_
 #define CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 18 matching lines @@
 
 // Used to describe the state of a multi-display configuration.
 enum OutputState {
   STATE_INVALID,
   STATE_HEADLESS,
   STATE_SINGLE,
   STATE_DUAL_MIRROR,
   STATE_DUAL_EXTENDED,
 };
 
+// Video output types.
+enum OutputType {
+  OUTPUT_TYPE_NONE = 0,
+  OUTPUT_TYPE_UNKNOWN = 1 << 0,
+  OUTPUT_TYPE_INTERNAL = 1 << 1,
+  OUTPUT_TYPE_VGA = 1 << 2,
+  OUTPUT_TYPE_HDMI = 1 << 3,
+  OUTPUT_TYPE_DVI = 1 << 4,
+  OUTPUT_TYPE_DISPLAYPORT = 1 << 5,
+};
+
+// Content protection methods applied on video output.
+enum OutputProtectionMethod {
+  OUTPUT_PROTECTION_METHOD_NONE = 0,
+  OUTPUT_PROTECTION_METHOD_HDCP = 1 << 0,
+};
+
+// HDCP protection state.
+enum HDCPState {
+  HDCP_STATE_UNDESIRED,
+  HDCP_STATE_DESIRED,
+  HDCP_STATE_ENABLED
+};
+
 // This class interacts directly with the underlying Xrandr API to manipulate
 // CTRCs and Outputs.
 class CHROMEOS_EXPORT OutputConfigurator
     : public base::MessageLoop::Dispatcher,
       public base::MessagePumpObserver {
  public:
+  typedef uint64_t OutputProtectionClientId;
+
   struct ModeInfo {
     ModeInfo();
     ModeInfo(int width, int height, bool interlaced, float refresh_rate);
 
     int width;
     int height;
     bool interlaced;
     float refresh_rate;
   };
 
@@ skipping 33 matching lines @@
     RRMode selected_mode;
 
     // Output's origin on the framebuffer.
     int x;
     int y;
 
     // Output's physical dimensions.
     uint64 width_mm;
     uint64 height_mm;
 
     bool is_internal;

[Daniel Erat, 2013/09/23 19:31:43]

mind adding a TODO to remove this, since it should probably be possible to just
check type == OUTPUT_TYPE_INTERNAL instead now?

[kcwu, 2013/09/24 13:55:06]

Done.

     bool is_aspect_preserving_scaling;
 
+    // The type of output.
+    OutputType type;
+
     // Map from mode IDs to details about the corresponding modes.
     ModeInfoMap mode_infos;
 
     // XInput device ID or 0 if this output isn't a touchscreen.
     int touch_device_id;
 
     CoordinateTransformation transform;
 
     // Display id for this output.
     int64 display_id;
@@ skipping 104 matching lines @@
     // |touch_device_id| the ID of the touchscreen device to configure.
     // |ctm| contains the desired transformation parameters.  The offsets
     // in it should be normalized so that 1 corresponds to the X or Y axis
     // size for the corresponding offset.
     virtual void ConfigureCTM(int touch_device_id,
                               const CoordinateTransformation& ctm) = 0;
 
     // Sends a D-Bus message to the power manager telling it that the
     // machine is or is not projecting.
     virtual void SendProjectingStateToPowerManager(bool projecting) = 0;
+
+    // Gets HDCP state of output.
+    virtual bool GetHDCPState(RROutput id, HDCPState* state) = 0;
+
+    // Sets HDCP state of output.
+    virtual bool SetHDCPState(RROutput id, HDCPState state) = 0;
   };
 
   // Helper class used by tests.
   class TestApi {
    public:
     TestApi(OutputConfigurator* configurator, int xrandr_event_base)
         : configurator_(configurator),
           xrandr_event_base_(xrandr_event_base) {}
     ~TestApi() {}
 
@@ skipping 116 matching lines @@
   void ResumeDisplays();
 
   const std::map<int, float>& GetMirroredDisplayAreaRatioMap() {
     return mirrored_display_area_ratio_map_;
   }
 
   // Configure outputs with |kConfigureDelayMs| delay,
   // so that time-consuming ConfigureOutputs() won't be called multiple times.
   void ScheduleConfigureOutputs();
 
+  // Registers a client for output protection and requests a client id. Returns
+  // 0 if requesting failed.
+  OutputProtectionClientId RegisterOutputProtectionClient();
+
+  // Unregisters the client.
+  void UnregisterOutputProtectionClient(OutputProtectionClientId client_id);
+
+  // Queries link status and protection status.
+  // |link_mask| is the type of connected output links, which is a bitmask of
+  // OutputType values. |protection_mask| is the desired protection methods,
+  // which is a bitmask of the OutputProtectionMethod values.
+  // Returns true on success.
+  bool QueryOutputProtectionStatus(
+      OutputProtectionClientId client_id,
+      uint32_t* link_mask,
+      uint32_t* protection_mask);
+
+  // Requests the desired protection methods.
+  // |protection_mask| is the desired protection methods, which is a bitmask
+  // of the OutputProtectionMethod values.
+  // Returns true when the protection request has been made.
+  bool EnableOutputProtection(
+      OutputProtectionClientId client_id,
+      uint32_t desired_protection_mask);
+
  private:
+  // Mapping a client to its protection request bitmask.
+  typedef std::map<chromeos::OutputConfigurator::OutputProtectionClientId,
+                   uint32_t> ProtectionRequests;
+
   // Returns currently-connected outputs. This method is a wrapper around
   // |delegate_->GetOutputs()| that does additional work, like finding the
   // mirror mode and setting user-preferred modes. Note that the server must
   // be grabbed via |delegate_->GrabServer()| first.
   std::vector<OutputSnapshot> GetOutputs();
 
   // Helper method for GetOutputs() that initializes the passed-in outputs'
   // |mirror_mode| fields by looking for a mode in |internal_output| and
   // |external_output| having the same resolution. Returns false if a shared
   // mode wasn't found or created.
@@ skipping 84 matching lines @@
   // Most-recently-used output configuration. Note that the actual
   // configuration changes asynchronously.
   std::vector<OutputSnapshot> cached_outputs_;
 
   ObserverList<Observer> observers_;
 
   // The timer to delay configuring outputs. See also the comments in
   // Dispatch().
   scoped_ptr<base::OneShotTimer<OutputConfigurator> > configure_timer_;
 
+  // Id for next output protection client.
+  OutputProtectionClientId next_output_protection_client_id_;
+
+  // Output protection requests of each client.
+  ProtectionRequests client_protection_requests_;
+
   DISALLOW_COPY_AND_ASSIGN(OutputConfigurator);
 };
 
 typedef std::vector<OutputConfigurator::OutputSnapshot> OutputSnapshotList;
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_