PPAPI: Make output protection API work with mus+ash

ui/display/manager/chromeos/display_configurator.h

 // 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.
 
 #ifndef UI_DISPLAY_MANAGER_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 #define UI_DISPLAY_MANAGER_CHROMEOS_DISPLAY_CONFIGURATOR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 26 matching lines @@
 class DisplayLayoutManager;
 class DisplayMode;
 class DisplaySnapshot;
 class NativeDisplayDelegate;
 class UpdateDisplayConfigurationTask;
 
 // This class interacts directly with the system display configurator.
 class DISPLAY_MANAGER_EXPORT DisplayConfigurator
     : public NativeDisplayObserver {
  public:
-  typedef uint64_t ContentProtectionClientId;
-  static const ContentProtectionClientId kInvalidClientId = 0;
-
-  typedef base::Callback<void(bool /* success */)> ConfigurationCallback;
-
-  typedef base::Callback<void(bool /* success */)> EnableProtectionCallback;
-
-  struct QueryProtectionResponse {
-    // True if the query succeeded, false otherwise.
-    bool success = false;
-
-    // The type of connected display links, which is a bitmask of
-    // DisplayConnectionType values.
-    uint32_t link_mask = 0;
-
-    // The desired protection methods, which is a bitmask of the
-    // ContentProtectionMethod values.
-    uint32_t protection_mask = 0;
+  enum : uint64_t {
+    INVALID_CLIENT_ID = 0,
   };
 
-  typedef base::Callback<void(const QueryProtectionResponse&)>
-      QueryProtectionCallback;
+  using ConfigurationCallback = base::Callback<void(bool /* success */)>;
 
-  typedef base::Callback<void(bool /* success */)> DisplayControlCallback;
+  using SetProtectionCallback = base::Callback<void(bool /* success */)>;
 
-  typedef std::vector<DisplaySnapshot*> DisplayStateList;
+  // link_mask: The type of connected display links, which is a bitmask of
+  // DisplayConnectionType values.
+  // protection_mask: The desired protection methods, which is a bitmask of the
+  // ContentProtectionMethod values.
+  using QueryProtectionCallback =
+      base::Callback<void(bool /* success */,
+                          uint32_t /* link_mask */,
+                          uint32_t /* protection_mask */)>;
+  using DisplayControlCallback = base::Callback<void(bool /* success */)>;
+
+  using DisplayStateList = std::vector<DisplaySnapshot*>;
 
   // Mapping a display_id to a protection request bitmask.
-  typedef std::map<int64_t, uint32_t> ContentProtections;
+  using ContentProtections = std::map<int64_t, uint32_t>;
 
   class Observer {
    public:
     virtual ~Observer() {}
 
     // Called after the display mode has been changed. |display| contains the
     // just-applied configuration. Note that the X server is no longer grabbed
     // when this method is called, so the actual configuration could've changed
     // already.
     virtual void OnDisplayModeChanged(const DisplayStateList& displays) {}
@@ skipping 170 matching lines @@
   // machines where display configuration is slow. On completion of the display
   // configuration |callback| is executed synchronously or asynchronously.
   void SuspendDisplays(const ConfigurationCallback& callback);
 
   // Reprobes displays to handle changes made while the system was
   // suspended.
   void ResumeDisplays();
 
   // Registers a client for display protection and requests a client id. Returns
   // 0 if requesting failed.
-  ContentProtectionClientId RegisterContentProtectionClient();
+  uint64_t RegisterContentProtectionClient();
 
   // Unregisters the client.
-  void UnregisterContentProtectionClient(ContentProtectionClientId client_id);
+  void UnregisterContentProtectionClient(uint64_t client_id);
 
   // Queries link status and protection status. |callback| is used to respond
   // to the query.
-  void QueryContentProtectionStatus(ContentProtectionClientId client_id,
+  void QueryContentProtectionStatus(uint64_t client_id,
                                     int64_t display_id,
                                     const QueryProtectionCallback& callback);
 
   // Requests the desired protection methods.
   // |protection_mask| is the desired protection methods, which is a bitmask
   // of the ContentProtectionMethod values.
   // Returns true when the protection request has been made.
-  void EnableContentProtection(ContentProtectionClientId client_id,
-                               int64_t display_id,
-                               uint32_t protection_mask,
-                               const EnableProtectionCallback& callback);
+  void SetContentProtection(uint64_t client_id,
+                            int64_t display_id,
+                            uint32_t protection_mask,
+                            const SetProtectionCallback& callback);
 
   // Checks the available color profiles for |display_id| and fills the result
   // into |profiles|.
   std::vector<ColorCalibrationProfile> GetAvailableColorCalibrationProfiles(
       int64_t display_id);
 
   // Updates the color calibration to |new_profile|.
   bool SetColorCalibrationProfile(int64_t display_id,
                                   ColorCalibrationProfile new_profile);
 
   // Enables/disables virtual display.
   int64_t AddVirtualDisplay(const gfx::Size& display_size);
   bool RemoveVirtualDisplay(int64_t display_id);
 
   // Returns true if there is at least one display on.
   bool IsDisplayOn() const;
 
   // Sets the gamma, degamma and correction matrix for |display_id| to the
   // values in |degamma_lut|, |gamma_lut| and |correction_matrix|.
   bool SetColorCorrection(int64_t display_id,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,
                           const std::vector<float>& correction_matrix);
 
  private:
   class DisplayLayoutManagerImpl;
 
   // Mapping a client to its protection request.
-  typedef std::map<ContentProtectionClientId, ContentProtections>
-      ProtectionRequests;
+  using ProtectionRequests = std::map<uint64_t, ContentProtections>;
 
   // Updates |pending_*| members and applies the passed-in state. |callback| is
   // invoked (perhaps synchronously) on completion.
   void SetDisplayPowerInternal(chromeos::DisplayPowerState power_state,
                                int flags,
                                const ConfigurationCallback& callback);
 
   // Configures displays. Invoked by |configure_timer_|.
   void ConfigureDisplays();
 
@@ skipping 33 matching lines @@
   // |in_progress_configuration_callbacks_| and
   // |queued_configuration_callbacks_| and clear the lists after. |success| is
   // the configuration status used when calling the callbacks.
   void CallAndClearInProgressCallbacks(bool success);
   void CallAndClearQueuedCallbacks(bool success);
 
   // Content protection callbacks called by the tasks when they finish. These
   // are responsible for destroying the task, replying to the caller that made
   // the task and starting the a new content protection task if one is queued.
   void OnContentProtectionQueried(
-      ContentProtectionClientId client_id,
+      uint64_t client_id,
       int64_t display_id,
       QueryContentProtectionTask::Response response);
-  void OnContentProtectionEnabled(ContentProtectionClientId client_id,
-                                  int64_t display_id,
-                                  uint32_t desired_method_mask,
-                                  bool success);
+  void OnSetContentProtectionCompleted(uint64_t client_id,
+                                       int64_t display_id,
+                                       uint32_t desired_method_mask,
+                                       bool success);
   void OnContentProtectionClientUnregistered(bool success);
 
   // Callbacks used to signal when the native platform has released/taken
   // display control.
   void OnDisplayControlTaken(const DisplayControlCallback& callback,
                              bool success);
   void OnDisplayControlRelinquished(const DisplayControlCallback& callback,
                                     bool success);
 
   // Helper function that sends the actual command.
@@ skipping 45 matching lines @@
   // start/finish. Note these callbacks belong to the pending request, not a
   // request currently active.
   std::vector<ConfigurationCallback> queued_configuration_callbacks_;
 
   // List of callbacks belonging to the currently running display configuration
   // task.
   std::vector<ConfigurationCallback> in_progress_configuration_callbacks_;
 
   std::queue<base::Closure> content_protection_tasks_;
   std::queue<QueryProtectionCallback> query_protection_callbacks_;
-  std::queue<EnableProtectionCallback> enable_protection_callbacks_;
+  std::queue<SetProtectionCallback> set_protection_callbacks_;
 
   // True if the caller wants to force the display configuration process.
   bool force_configure_;
 
   // Most-recently-used display configuration. Note that the actual
   // configuration changes asynchronously.
   DisplayStateList cached_displays_;
 
   // Most-recently-used framebuffer size.
   gfx::Size framebuffer_size_;
 
   base::ObserverList<Observer> observers_;
 
   // The timer to delay configuring displays. This is used to aggregate multiple
   // display configuration events when they are reported in short time spans.
   // See comment for NativeDisplayEventDispatcherX11 for more details.
   base::OneShotTimer configure_timer_;
 
   // Id for next display protection client.
-  ContentProtectionClientId next_display_protection_client_id_;
+  uint64_t next_display_protection_client_id_;
 
   // Display protection requests of each client.
   ProtectionRequests client_protection_requests_;
 
   // Display controlled by an external entity.
   bool display_externally_controlled_;
 
   // True if a TakeControl or RelinquishControl has been called but the response
   // hasn't arrived yet.
   bool display_control_changing_;
@@ skipping 13 matching lines @@
 
   // This must be the last variable.
   base::WeakPtrFactory<DisplayConfigurator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayConfigurator);
 };
 
 }  // namespace display
 
 #endif  // UI_DISPLAY_MANAGER_CHROMEOS_DISPLAY_CONFIGURATOR_H_