[1/8] Prepare Pepper for async output protection configuration

ui/display/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/chromeos/display_configurator.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
@@ skipping 107 matching lines @@
     CALLBACK_FAILURE,
     CALLBACK_SUCCESS,
     CALLBACK_NOT_CALLED,
   };
 
   DisplayConfiguratorTest()
       : small_mode_(gfx::Size(1366, 768), false, 60.0f),
         big_mode_(gfx::Size(2560, 1600), false, 60.0f),
         observer_(&configurator_),
         test_api_(&configurator_),
+        enable_content_protection_status_(0),
+        enable_content_protection_call_count_(0),
+        query_content_protection_status_(0),
+        link_mask_(0),
+        protection_mask_(0),
+        query_content_protection_call_count_(0),
         callback_result_(CALLBACK_NOT_CALLED) {}
   ~DisplayConfiguratorTest() override {}
 
   void SetUp() override {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetDelegateForTesting(
         scoped_ptr<NativeDisplayDelegate>(native_display_delegate_));
 
@@ skipping 20 matching lines @@
     o->set_is_aspect_preserving_scaling(true);
     o->set_display_id(456);
 
     UpdateOutputs(2, false);
   }
 
   void OnConfiguredCallback(bool status) {
     callback_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
   }
 
+  void EnableContentProtectionCallback(bool status) {
+    enable_content_protection_status_ = status;
+    enable_content_protection_call_count_++;
+  }
+
+  void QueryContentProtectionCallback(bool status,
+                                      uint32_t link_mask,
+                                      uint32_t protection_mask) {
+    query_content_protection_status_ = status;
+    link_mask_ = link_mask;
+    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
   // |outputs_|. If |send_events| is true, also sends screen-change and
   // output-change events to |configurator_| and triggers the configure
   // timeout if one was scheduled.
@@ skipping 34 matching lines @@
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   DisplayConfigurator configurator_;
   TestObserver observer_;
   scoped_ptr<ActionLogger> log_;
   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
   DisplayConfigurator::TestApi test_api_;
 
+  bool enable_content_protection_status_;
+  int enable_content_protection_call_count_;
+  bool query_content_protection_status_;
+  uint32_t link_mask_;
+  uint32_t protection_mask_;
+  int query_content_protection_call_count_;
+
   TestDisplaySnapshot outputs_[2];
 
   CallbackResult callback_result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 };
 
 }  // namespace
 
@@ skipping 698 matching lines @@
   configurator_.ForceInitialConfigure(0);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
   DisplayConfigurator::ContentProtectionClientId id =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(0u, id);
 
   // One output.
   UpdateOutputs(1, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
-  uint32_t link_mask = 0;
-  uint32_t protection_mask = 0;
-  EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
-      id, outputs_[0].display_id(), &link_mask, &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL), link_mask);
+  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_status_);
+  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL),
+            link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
-            protection_mask);
+            protection_mask_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Two outputs.
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
-  EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
-      id, outputs_[1].display_id(), &link_mask, &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
+  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_status_);
+  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
-            protection_mask);
+            protection_mask_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      id, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
+  configurator_.EnableContentProtection(
+      id, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED),
             log_->GetActionsAndClear());
 
   // Enable protection.
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
-  EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
-      id, outputs_[1].display_id(), &link_mask, &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
+  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_status_);
+  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask_);
   EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_HDCP),
-            protection_mask);
+            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 98 matching lines @@
   DisplayConfigurator::ContentProtectionClientId client2 =
       configurator_.RegisterContentProtectionClient();
   EXPECT_NE(client1, client2);
 
   configurator_.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.
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
+  configurator_.EnableContentProtection(
+      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(GetSetHDCPStateAction(outputs_[1], HDCP_STATE_DESIRED).c_str(),
             log_->GetActionsAndClear());
   native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
-  uint32_t link_mask = 0;
-  uint32_t protection_mask = 0;
-  EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
-      client1, outputs_[1].display_id(), &link_mask, &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
-  EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP, protection_mask);
+  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_status_);
+  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask_);
+  EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP, protection_mask_);
 
-  EXPECT_TRUE(configurator_.QueryContentProtectionStatus(
-      client2, outputs_[1].display_id(), &link_mask, &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask);
-  EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE, 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_status_);
+  EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI), link_mask_);
+  EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE, protection_mask_);
 
   // Protections will be disabled only if no more clients request them.
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE));
+  configurator_.EnableContentProtection(
+      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE));
+
+  configurator_.EnableContentProtection(
+      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_NONE,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(3, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_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();
   EXPECT_NE(client1, client2);
 
   configurator_.Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   log_->GetActionsAndClear();
 
   // Only enable once if HDCP is enabling.
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
+  configurator_.EnableContentProtection(
+      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
   native_display_delegate_->set_hdcp_state(HDCP_STATE_DESIRED);
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
+  configurator_.EnableContentProtection(
+      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_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.
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
-  EXPECT_TRUE(configurator_.EnableContentProtection(
-      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP));
+  configurator_.EnableContentProtection(
+      client1, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(3, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
+  configurator_.EnableContentProtection(
+      client2, outputs_[1].display_id(), CONTENT_PROTECTION_METHOD_HDCP,
+      base::Bind(&DisplayConfiguratorTest::EnableContentProtectionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(4, enable_content_protection_call_count_);
+  EXPECT_TRUE(enable_content_protection_status_);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, HandleConfigureCrtcFailure) {
   InitWithSingleOutput();
 
   ScopedVector<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 204 matching lines @@
                         GetFramebufferAction(small_mode_.size(), &outputs_[0],
                                              nullptr).c_str(),
                         GetCrtcAction(outputs_[0], &small_mode_,
                                       gfx::Point(0, 0)).c_str(),
                         kUngrab, NULL),
             log_->GetActionsAndClear());
 }
 
 }  // namespace test
 }  // namespace ui