Pepper API implementation for output protection.

chromeos/display/real_output_configurator_delegate.h

 // 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.
 
 #ifndef CHROMEOS_DISPLAY_REAL_OUTPUT_CONFIGURATOR_DELEGATE_H_
 #define CHROMEOS_DISPLAY_REAL_OUTPUT_CONFIGURATOR_DELEGATE_H_
 
+#include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "chromeos/display/output_configurator.h"
+#include "ppapi/c/private/ppb_output_protection_private.h"
 
 typedef XID Window;
 
 struct _XDisplay;
 typedef struct _XDisplay Display;
 struct _XRROutputInfo;
 typedef _XRROutputInfo XRROutputInfo;
 struct _XRRScreenResources;
 typedef _XRRScreenResources XRRScreenResources;
 
+namespace chrome {
+class PepperOutputProtectionHost;
+}  // namespace chrome
+
 namespace chromeos {
 
 class RealOutputConfiguratorDelegate : public OutputConfigurator::Delegate {
  public:
   RealOutputConfiguratorDelegate();
   virtual ~RealOutputConfiguratorDelegate();
 
   // OutputConfigurator::Delegate overrides:
   virtual void SetPanelFittingEnabled(bool enabled) OVERRIDE;
   virtual void InitXRandRExtension(int* event_base) OVERRIDE;
@@ skipping 13 matching lines @@
       int x,
       int y) OVERRIDE;
   virtual void CreateFrameBuffer(
       int width,
       int height,
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) OVERRIDE;
   virtual void ConfigureCTM(
       int touch_device_id,
       const OutputConfigurator::CoordinateTransformation& ctm) OVERRIDE;
   virtual void SendProjectingStateToPowerManager(bool projecting) OVERRIDE;
+  virtual bool QueryOutputProtectionStatus(
+      chrome::PepperOutputProtectionHost* client,
+      uint32_t* link_mask,
+      uint32_t* protection_mask) OVERRIDE;
+  virtual bool EnableOutputProtection(
+      chrome::PepperOutputProtectionHost* client,
+      uint32_t desired_method_mask) OVERRIDE;
 
  private:
+  typedef std::map<chrome::PepperOutputProtectionHost*, uint32_t>
+      ProtectionRequests;

[dmichael (off chromium), 2013/09/09 20:37:15]

You might want IDMap instead. That would get rid of the weird-looking usage of
|this| in the host destructor (which I think I understand now that I've gotten
this far).

[kcwu, 2013/09/10 12:50:21]

IDMap looks good. What do you suggest how to use IDMap?
How about:
- The delegate holds two table, one is IDMap (pointer -> id) and the other is
(id -> request).
- Pepper hosts have to register to delegate first and get the id.
- Pepper hosts call QueryStatus(), Enable(), and Unregister in dtor with id.

[dmichael (off chromium), 2013/09/11 18:22:45]

I was suggesting using IDMap here, and you can have an initial "RegisterClient"
method that adds an entry to the map and returns the client ID.
EnableOutputProtection and EnableOutputProtection would use the same ID instead
of a raw pointer.

It's not functionally any better, but probably safer in the long run.

[kcwu, 2013/09/12 18:22:08]

How about void* as Dale suggested?
I would modify it to use IDMap tomorrow.

+
+  enum HDCPState {
+    HDCP_State_Undesired,
+    HDCP_State_Desired,
+    HDCP_State_Enabled
+  };
+
   // Gets details corresponding to |mode|. Parameters may be NULL. Returns
   // true on success.
   bool GetModeDetails(RRMode mode, int* width, int* height, bool* interlaced);
 
   // Helper method for GetOutputs() that returns an OutputSnapshot struct based
   // on the passed-in information. Further initialization is required (e.g.
   // |selected_mode|, |mirror_mode|, and |touch_device_id|).
   OutputConfigurator::OutputSnapshot InitOutputSnapshot(
       RROutput id,
       XRROutputInfo* info,
@@ skipping 30 matching lines @@
                               RRMode* external_mirror_mode);
 
   // Searches for touchscreens among input devices,
   // and tries to match them up to screens in |outputs|.
   // |outputs| is an array of detected screens.
   // If a touchscreen with same resolution as an output's native mode
   // is detected, its id will be stored in this output.
   void GetTouchscreens(
       std::vector<OutputConfigurator::OutputSnapshot>* outputs);
 
+  // Get HDCP state of output.
+  bool GetHDCPState(RROutput id, HDCPState* state);
+  // Set HDCP state of output.
+  bool SetHDCPState(RROutput id, HDCPState state);
+  // Get types of connected output links.
+  bool GetOutputLinkType(
+      std::vector<PP_OutputProtectionLinkType_Private>& link_type);
+  // Get the bit-mask of connected output links.
+  bool GetOutputLinkMask(uint32_t* link_mask);
+  // Get the bit-mask of enabled protection methods.
+  bool GetProtectionMethods(uint32_t* protection_mask);
+  // Get the bit-mask of all requested protection methods.
+  uint32_t GetCombinedProtectionRequest();
+
   Display* display_;
   Window window_;
 
   // Initialized when the server is grabbed and freed when it's ungrabbed.
   XRRScreenResources* screen_;
 
   // Used to enable modes which rely on panel fitting.
   bool is_panel_fitting_enabled_;
 
+  // Output protection requests of each client.
+  ProtectionRequests client_protection_request_;
+
   DISALLOW_COPY_AND_ASSIGN(RealOutputConfiguratorDelegate);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DISPLAY_REAL_OUTPUT_CONFIGURATOR_DELEGATE_H_