display: Improve HDCP unit tests

This CL makes TestNativeDisplayDelegate::SetHDCPState stateful to allow
validating HDCP state in unit tests, and defers ActionLogger logging in
the asynchronous case.

Bug: 929449
Test: display_unittests
Change-Id: Ic12703e440ba4a8a6fb0733e44a29e739beb4f6f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1597697
Commit-Queue: Dominik Laskowski <domlaskowski@chromium.org>
Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Cr-Commit-Position: refs/heads/master@{#660527}

ui/display/manager/apply_content_protection_task_unittest.cc

@@ -23,11 +23,12 @@ namespace test {
 
 namespace {
 
+constexpr int64_t kDisplayId = 1;
+
 std::unique_ptr<DisplaySnapshot> CreateDisplaySnapshot(
-    int64_t id,
     DisplayConnectionType type) {
   return FakeDisplaySnapshot::Builder()
-      .SetId(id)
+      .SetId(kDisplayId)
       .SetNativeMode(gfx::Size(1024, 768))
       .SetType(type)
       .Build();
@@ -55,8 +56,7 @@ class ApplyContentProtectionTaskTest : public testing::Test {
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToInternalDisplay) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(
-      CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_INTERNAL));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_INTERNAL));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
 
@@ -74,7 +74,7 @@ TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToInternalDisplay) {
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToExternalDisplay) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_HDMI));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_HDMI));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
 
@@ -87,17 +87,13 @@ TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToExternalDisplay) {
   task.Run();
 
   EXPECT_EQ(Response::SUCCESS, response_);
-  EXPECT_EQ(
-      JoinActions(GetSetHDCPStateAction(*layout_manager.GetDisplayStates()[0],
-                                        HDCP_STATE_DESIRED)
-                      .c_str(),
-                  NULL),
-      log_.GetActionsAndClear());
+  EXPECT_EQ(GetSetHDCPStateAction(kDisplayId, HDCP_STATE_DESIRED).c_str(),
+            log_.GetActionsAndClear());
 }
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToUnknownDisplay) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_UNKNOWN));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_UNKNOWN));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
 
@@ -115,7 +111,7 @@ TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToUnknownDisplay) {
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToDisplayThatCannotGetHdcp) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_HDMI));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_HDMI));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
   display_delegate_.set_get_hdcp_state_expectation(false);
@@ -134,7 +130,7 @@ TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToDisplayThatCannotGetHdcp) {
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToDisplayThatCannotSetHdcp) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_HDMI));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_HDMI));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
   display_delegate_.set_set_hdcp_state_expectation(false);
@@ -148,17 +144,13 @@ TEST_F(ApplyContentProtectionTaskTest, ApplyHdcpToDisplayThatCannotSetHdcp) {
   task.Run();
 
   EXPECT_EQ(Response::FAILURE, response_);
-  EXPECT_EQ(
-      JoinActions(GetSetHDCPStateAction(*layout_manager.GetDisplayStates()[0],
-                                        HDCP_STATE_DESIRED)
-                      .c_str(),
-                  NULL),
-      log_.GetActionsAndClear());
+  EXPECT_EQ(GetSetHDCPStateAction(kDisplayId, HDCP_STATE_DESIRED).c_str(),
+            log_.GetActionsAndClear());
 }
 
 TEST_F(ApplyContentProtectionTaskTest, ApplyNoProtectionToExternalDisplay) {
   std::vector<std::unique_ptr<DisplaySnapshot>> displays;
-  displays.push_back(CreateDisplaySnapshot(1, DISPLAY_CONNECTION_TYPE_HDMI));
+  displays.push_back(CreateDisplaySnapshot(DISPLAY_CONNECTION_TYPE_HDMI));
   TestDisplayLayoutManager layout_manager(std::move(displays),
                                           MULTIPLE_DISPLAY_STATE_SINGLE);
   display_delegate_.set_hdcp_state(HDCP_STATE_UNDESIRED);

ui/display/manager/test/action_logger_util.cc

@@ -32,10 +32,9 @@ std::string GetCrtcAction(const DisplaySnapshot& output,
                             mode ? mode->ToString().c_str() : "NULL");
 }
 
-std::string GetSetHDCPStateAction(const DisplaySnapshot& output,
-                                  HDCPState state) {
-  return base::StringPrintf("set_hdcp(id=%" PRId64 ",state=%d)",
-                            output.display_id(), state);
+std::string GetSetHDCPStateAction(int64_t display_id, HDCPState state) {
+  return base::StringPrintf("set_hdcp(id=%" PRId64 ",state=%d)", display_id,
+                            state);
 }
 
 std::string SetColorMatrixAction(int64_t display_id,

ui/display/manager/test/action_logger_util.h

@@ -43,8 +43,7 @@ std::string GetCrtcAction(const DisplaySnapshot& output,
                           const gfx::Point& origin);
 
 // Returns a string describing a TestNativeDisplayDelegate::SetHDCPState() call.
-std::string GetSetHDCPStateAction(const DisplaySnapshot& output,
-                                  HDCPState state);
+std::string GetSetHDCPStateAction(int64_t display_id, HDCPState state);
 
 // Returns a string describing a TestNativeDisplayDelegate::SetColorMatrix()
 // call.

ui/display/manager/test/test_native_display_delegate.cc

@@ -10,6 +10,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "ui/display/manager/test/action_logger.h"
 #include "ui/display/types/display_mode.h"
+#include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_observer.h"
 
 namespace display {
@@ -95,16 +96,40 @@ void TestNativeDisplayDelegate::GetHDCPState(const DisplaySnapshot& output,
 void TestNativeDisplayDelegate::SetHDCPState(const DisplaySnapshot& output,
                                              HDCPState state,
                                              SetHDCPStateCallback callback) {
-  log_->AppendAction(GetSetHDCPStateAction(output, state));
-
   if (run_async_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), set_hdcp_expectation_));
+        FROM_HERE, base::BindOnce(&TestNativeDisplayDelegate::DoSetHDCPState,
+                                  base::Unretained(this), output.display_id(),
+                                  state, std::move(callback)));
   } else {
-    std::move(callback).Run(set_hdcp_expectation_);
+    DoSetHDCPState(output.display_id(), state, std::move(callback));
   }
 }
 
+void TestNativeDisplayDelegate::DoSetHDCPState(int64_t display_id,
+                                               HDCPState state,
+                                               SetHDCPStateCallback callback) {
+  log_->AppendAction(GetSetHDCPStateAction(display_id, state));
+
+  switch (state) {
+    case HDCP_STATE_ENABLED:
+      NOTREACHED();
+      break;
+
+    case HDCP_STATE_DESIRED:
+      hdcp_state_ =
+          set_hdcp_expectation_ ? HDCP_STATE_ENABLED : HDCP_STATE_DESIRED;
+      break;
+
+    case HDCP_STATE_UNDESIRED:
+      if (set_hdcp_expectation_)
+        hdcp_state_ = HDCP_STATE_UNDESIRED;
+      break;
+  }
+
+  std::move(callback).Run(set_hdcp_expectation_);
+}
+
 bool TestNativeDisplayDelegate::SetColorMatrix(
     int64_t display_id,
     const std::vector<float>& color_matrix) {

ui/display/manager/test/test_native_display_delegate.h

@@ -47,6 +47,7 @@ class TestNativeDisplayDelegate : public NativeDisplayDelegate {
     set_hdcp_expectation_ = success;
   }
 
+  HDCPState hdcp_state() const { return hdcp_state_; }
   void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
 
   void set_run_async(bool run_async) { run_async_ = run_async; }
@@ -80,6 +81,10 @@ class TestNativeDisplayDelegate : public NativeDisplayDelegate {
                  const DisplayMode* mode,
                  const gfx::Point& origin);
 
+  void DoSetHDCPState(int64_t display_id,
+                      HDCPState state,
+                      SetHDCPStateCallback callback);
+
   // Outputs to be returned by GetDisplays().
   std::vector<DisplaySnapshot*> outputs_;