PPAPI: Make output protection API work with mus+ash

ui/display/manager/chromeos/display_configurator_unittest.cc

 // 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.
 
 #include "ui/display/manager/chromeos/display_configurator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
@@ skipping 187 matching lines @@
 };
 
 class DisplayConfiguratorTest : public testing::Test {
  public:
   DisplayConfiguratorTest()
       : small_mode_(gfx::Size(1366, 768), false, 60.0f),
         big_mode_(gfx::Size(2560, 1600), false, 60.0f),
         observer_(&configurator_),
         test_api_(&configurator_),
         config_waiter_(&test_api_),
-        enable_content_protection_status_(0),
-        enable_content_protection_call_count_(0),
+        set_content_protection_status_(false),
+        set_content_protection_call_count_(0),
+        query_content_protection_response_success_(false),
+        query_content_protection_response_link_mask_(0),
+        query_content_protection_response_protection_mask_(0),
         query_content_protection_call_count_(0),
         display_control_result_(CALLBACK_NOT_CALLED) {}
   ~DisplayConfiguratorTest() override {}
 
   void SetUp() override {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetDelegateForTesting(
         std::unique_ptr<NativeDisplayDelegate>(native_display_delegate_));
@@ skipping 26 matching lines @@
                       .SetIsAspectPerservingScaling(true)
                       .Build();
 
     UpdateOutputs(2, false);
   }
 
   void OnDisplayControlUpdated(bool status) {
     display_control_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
   }
 
-  void EnableContentProtectionCallback(bool status) {
-    enable_content_protection_status_ = status;
-    enable_content_protection_call_count_++;
+  void SetContentProtectionCallback(bool status) {
+    set_content_protection_status_ = status;
+    set_content_protection_call_count_++;
   }
 
-  void QueryContentProtectionCallback(
-      const DisplayConfigurator::QueryProtectionResponse& response) {
-    query_content_protection_response_ = response;
+  void QueryContentProtectionCallback(bool success,
+                                      uint32_t link_mask,
+                                      uint32_t protection_mask) {
+    query_content_protection_response_success_ = success;
+    query_content_protection_response_link_mask_ = link_mask;
+    query_content_protection_response_protection_mask_ = protection_mask;
     query_content_protection_call_count_++;
   }
 
   // Predefined modes that can be used by outputs.
   const DisplayMode small_mode_;
   const DisplayMode big_mode_;
 
  protected:
   // Configures |native_display_delegate_| to return the first |num_outputs|
   // entries from
@@ skipping 43 matching lines @@
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   DisplayConfigurator configurator_;
   TestObserver observer_;
   std::unique_ptr<ActionLogger> log_;
   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
   DisplayConfigurator::TestApi test_api_;
   ConfigurationWaiter config_waiter_;
-  bool enable_content_protection_status_;
-  int enable_content_protection_call_count_;
-  DisplayConfigurator::QueryProtectionResponse
-      query_content_protection_response_;
+  bool set_content_protection_status_;
+  int set_content_protection_call_count_;
+  bool query_content_protection_response_success_;
+  uint32_t query_content_protection_response_link_mask_;
+  uint32_t query_content_protection_response_protection_mask_;
   int query_content_protection_call_count_;
 
   std::unique_ptr<DisplaySnapshot> outputs_[3];
 
   CallbackResult display_control_result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 };
 
@@ skipping 874 matching lines @@
   // snapshot that was passed to the observer (http://crbug.com/289159).
   DisplaySnapshot* state = observer_.latest_outputs()[0];
   ASSERT_EQ(2UL, state->modes().size());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtection) {
   Init(false);
   configurator_.ForceInitialConfigure(0);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
-  DisplayConfigurator::ContentProtectionClientId id =
-      configurator_.RegisterContentProtectionClient();
+  uint64_t id = configurator_.RegisterContentProtectionClient();
   EXPECT_NE(0u, id);
 
   // One output.
   UpdateOutputs(1, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
   configurator_.QueryContentProtectionStatus(
       id, outputs_[0]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, query_content_protection_call_count_);
-  EXPECT_TRUE(query_content_protection_response_.success);
+  EXPECT_TRUE(query_content_protection_response_success_);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL),
-            query_content_protection_response_.link_mask);
+            query_content_protection_response_link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
-            query_content_protection_response_.protection_mask);
+            query_content_protection_response_protection_mask_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Two outputs.
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
   configurator_.QueryContentProtectionStatus(
       id, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, query_content_protection_call_count_);
-  EXPECT_TRUE(query_content_protection_response_.success);
+  EXPECT_TRUE(query_content_protection_response_success_);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
-            query_content_protection_response_.link_mask);
+            query_content_protection_response_link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
-            query_content_protection_response_.protection_mask);
+            query_content_protection_response_protection_mask_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       id, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(1, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(1, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED),
             log_->GetActionsAndClear());
 
   // Enable protection.
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
   configurator_.QueryContentProtectionStatus(
       id, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, query_content_protection_call_count_);
-  EXPECT_TRUE(query_content_protection_response_.success);
+  EXPECT_TRUE(query_content_protection_response_success_);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
-            query_content_protection_response_.link_mask);
+            query_content_protection_response_link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_HDCP),
-            query_content_protection_response_.protection_mask);
+            query_content_protection_response_protection_mask_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Protections should be disabled after unregister.
   configurator_.UnregisterContentProtectionClient(id);
   EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED),
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, DoNotConfigureWithSuspendedDisplays) {
   InitWithSingleOutput();
@@ skipping 89 matching lines @@
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClients) {
-  DisplayConfigurator::ContentProtectionClientId client1 =
-      configurator_.RegisterContentProtectionClient();
-  DisplayConfigurator::ContentProtectionClientId client2 =
-      configurator_.RegisterContentProtectionClient();
+  uint64_t client1 = configurator_.RegisterContentProtectionClient();
+  uint64_t client2 = configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
   Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
   // Clients never know state enableness for methods that they didn't request.
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(1, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(1, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
             log_->GetActionsAndClear());
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
   configurator_.QueryContentProtectionStatus(
       client1, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, query_content_protection_call_count_);
-  EXPECT_TRUE(query_content_protection_response_.success);
+  EXPECT_TRUE(query_content_protection_response_success_);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
-            query_content_protection_response_.link_mask);
+            query_content_protection_response_link_mask_);
   EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP,
-            query_content_protection_response_.protection_mask);
+            query_content_protection_response_protection_mask_);
 
   configurator_.QueryContentProtectionStatus(
       client2, outputs_[1]->display_id(),
       base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, query_content_protection_call_count_);
-  EXPECT_TRUE(query_content_protection_response_.success);
+  EXPECT_TRUE(query_content_protection_response_success_);
   EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
-            query_content_protection_response_.link_mask);
+            query_content_protection_response_link_mask_);
   EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE,
-            query_content_protection_response_.protection_mask);
+            query_content_protection_response_protection_mask_);
 
   // Protections will be disabled only if no more clients request them.
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(2, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(2, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(3, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(3, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED).c_str(),
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClientsEnable) {
-  DisplayConfigurator::ContentProtectionClientId client1 =
-      configurator_.RegisterContentProtectionClient();
-  DisplayConfigurator::ContentProtectionClientId client2 =
-      configurator_.RegisterContentProtectionClient();
+  uint64_t client1 = configurator_.RegisterContentProtectionClient();
+  uint64_t client2 = configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
   Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   log_->GetActionsAndClear();
 
   // Only enable once if HDCP is enabling.
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(1, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(1, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   native_display_delegate_->set_hdcp_state(HDCP_STATE_DESIRED);
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(2, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(2, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
             log_->GetActionsAndClear());
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
   // Don't enable again if HDCP is already active.
-  configurator_.EnableContentProtection(
+  configurator_.SetContentProtection(
       client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(3, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
-  configurator_.EnableContentProtection(
+  EXPECT_EQ(3, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
+  configurator_.SetContentProtection(
       client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
-      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+      base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
                  base::Unretained(this)));
-  EXPECT_EQ(4, enable_content_protection_call_count_);
-  EXPECT_TRUE(enable_content_protection_status_);
+  EXPECT_EQ(4, set_content_protection_call_count_);
+  EXPECT_TRUE(set_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, HandleConfigureCrtcFailure) {
   InitWithSingleOutput();
 
   std::vector<std::unique_ptr<const DisplayMode>> modes;
   // The first mode is the mode we are requesting DisplayConfigurator to choose.
   // The test will be setup so that this mode will fail and it will have to
   // choose the next best option.
@@ skipping 667 matching lines @@
   configurator_.ResumeDisplays();
   EXPECT_EQ(kLongDelay, config_waiter_.Wait());
   EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
             configurator_.current_power_state());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
             configurator_.display_state());
 }
 
 }  // namespace test
 }  // namespace display