Unit tests for output protection in output configurator

chromeos/display/output_configurator_unittest.cc

 // Copyright (c) 2012 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 "chromeos/display/output_configurator.h"
 
 #include <cstdarg>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 54 matching lines @@
 }
 
 // Returns a string describing a TestDelegate::ConfigureCTM() call.
 std::string GetCTMAction(
     int device_id,
     const OutputConfigurator::CoordinateTransformation& ctm) {
   return base::StringPrintf("ctm(id=%d,transform=(%f,%f,%f,%f))", device_id,
       ctm.x_scale, ctm.x_offset, ctm.y_scale, ctm.y_offset);
 }
 
+// Returns a string describing a TestDelegate::SetHDCPState() call.
+std::string GetSetHDCPStateAction(RROutput id, HDCPState state) {
+  return base::StringPrintf("set_hdcp(id=%lu,state=%d)", id, state);
+}
+
 // Joins a sequence of strings describing actions (e.g. kScreenDim) such
 // that they can be compared against a string returned by
 // TestDelegate::GetActionsAndClear().  The list of actions must be
 // terminated by a NULL pointer.
 std::string JoinActions(const char* action, ...) {
   std::string actions;
 
   va_list arg_list;
   va_start(arg_list, action);
   while (action) {
     if (!actions.empty())
       actions += ",";
     actions += action;
     action = va_arg(arg_list, const char*);
   }
   va_end(arg_list);
   return actions;
 }
 
 class TestDelegate : public OutputConfigurator::Delegate {
  public:
   static const int kXRandREventBase = 10;
 
-  TestDelegate() : configure_crtc_result_(true) {}
+  TestDelegate()
+      : configure_crtc_result_(true),
+        hdcp_state_(HDCP_STATE_UNDESIRED) {}
   virtual ~TestDelegate() {}
 
   const std::vector<OutputConfigurator::OutputSnapshot>& outputs() const {
     return outputs_;
   }
   void set_outputs(
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
     outputs_ = outputs;
   }
 
   void set_configure_crtc_result(bool result) {
     configure_crtc_result_ = result;
   }
 
+  void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
+
   // Returns a comma-separated string describing the actions that were
   // requested since the previous call to GetActionsAndClear() (i.e.
   // results are non-repeatable).
   std::string GetActionsAndClear() {
     std::string actions = actions_;
     actions_.clear();
     return actions;
   }
 
   // OutputConfigurator::Delegate overrides:
@@ skipping 38 matching lines @@
   virtual void ConfigureCTM(
       int touch_device_id,
       const OutputConfigurator::CoordinateTransformation& ctm) OVERRIDE {
     AppendAction(GetCTMAction(touch_device_id, ctm));
   }
   virtual void SendProjectingStateToPowerManager(bool projecting) OVERRIDE {
     AppendAction(projecting ? kProjectingOn : kProjectingOff);
   }
 
   virtual bool GetHDCPState(RROutput id, HDCPState* state) OVERRIDE {
+    *state = hdcp_state_;
     return true;
   }
 
   virtual bool SetHDCPState(RROutput id, HDCPState state) OVERRIDE {
+    AppendAction(GetSetHDCPStateAction(id, state));
     return true;
   }
 
  private:
   struct ModeDetails {
     ModeDetails() : width(0), height(0), interlaced(false) {}
     ModeDetails(int width, int height, bool interlaced)
         : width(width),
           height(height),
           interlaced(interlaced) {}
@@ skipping 12 matching lines @@
   std::map<RRMode, ModeDetails> modes_;
 
   // Outputs to be returned by GetOutputs().
   std::vector<OutputConfigurator::OutputSnapshot> outputs_;
 
   std::string actions_;
 
   // Return value returned by ConfigureCrtc().
   bool configure_crtc_result_;
 
+  // Result value of GetHDCPState().
+  HDCPState hdcp_state_;
+
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 class TestObserver : public OutputConfigurator::Observer {
  public:
   explicit TestObserver(OutputConfigurator* configurator)
       : configurator_(configurator) {
     Reset();
     configurator_->AddObserver(this);
   }
@@ skipping 116 matching lines @@
     OutputConfigurator::ModeInfo big_mode_info;
     big_mode_info.width = kBigModeWidth;
     big_mode_info.height = kBigModeHeight;
 
     OutputConfigurator::OutputSnapshot* o = &outputs_[0];
     o->output = 1;
     o->crtc = 10;
     o->current_mode = kSmallModeId;
     o->native_mode = kSmallModeId;
     o->is_internal = true;
+    o->type = OUTPUT_TYPE_INTERNAL;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->has_display_id = true;
     o->index = 0;
 
     o = &outputs_[1];
     o->output = 2;
     o->crtc = 11;
     o->current_mode = kBigModeId;
     o->native_mode = kBigModeId;
     o->is_internal = false;
+    o->type = OUTPUT_TYPE_HDMI;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->mode_infos[kBigModeId] = big_mode_info;
     o->has_display_id = true;
     o->index = 1;
 
     UpdateOutputs(2, false);
   }
 
  protected:
@@ skipping 719 matching lines @@
 
   // Also check that the newly-added small mode is present in the internal
   // snapshot that was passed to the observer (http://crbug.com/289159).
   const OutputConfigurator::ModeInfo* info = OutputConfigurator::GetModeInfo(
       observer_.latest_outputs()[0], kSmallModeId);
   ASSERT_TRUE(info);
   EXPECT_EQ(kSmallModeWidth, info->width);
   EXPECT_EQ(kSmallModeHeight, info->height);
 }
 
+TEST_F(OutputConfiguratorTest, OutputProtection) {
+  configurator_.Init(false);
+  configurator_.Start(0);
+  EXPECT_NE(kNoActions, delegate_->GetActionsAndClear());
+
+  OutputConfigurator::OutputProtectionClientId id =
+      configurator_.RegisterOutputProtectionClient();
+  EXPECT_NE(0u, id);
+
+  // One output.
+  UpdateOutputs(1, true);
+  EXPECT_NE(kNoActions, delegate_->GetActionsAndClear());
+  uint32_t link_mask = 0;
+  uint32_t protection_mask = 0;
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id, &link_mask,
+                                                        &protection_mask));
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL), link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_NONE),
+            protection_mask);
+  EXPECT_EQ(kNoActions, delegate_->GetActionsAndClear());
+
+  // Two outputs.
+  UpdateOutputs(2, true);
+  EXPECT_NE(kNoActions, delegate_->GetActionsAndClear());
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id, &link_mask,
+                                                        &protection_mask));
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL | OUTPUT_TYPE_HDMI),
+            link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_NONE),
+            protection_mask);
+  EXPECT_EQ(kNoActions, delegate_->GetActionsAndClear());
+
+  EXPECT_TRUE(
+      configurator_.EnableOutputProtection(id, OUTPUT_PROTECTION_METHOD_HDCP));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED),
+            delegate_->GetActionsAndClear());
+
+  // Enable protection.
+  delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id, &link_mask,
+                                                        &protection_mask));
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL | OUTPUT_TYPE_HDMI),
+            link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_HDCP),
+            protection_mask);
+  EXPECT_EQ(kNoActions, delegate_->GetActionsAndClear());
+}
+
+TEST_F(OutputConfiguratorTest, OutputProtectionTwoClients) {
+  OutputConfigurator::OutputProtectionClientId client1 =
+      configurator_.RegisterOutputProtectionClient();
+  OutputConfigurator::OutputProtectionClientId client2 =
+      configurator_.RegisterOutputProtectionClient();
+  EXPECT_NE(client1, client2);
+
+  configurator_.Init(false);
+  configurator_.Start(0);
+  UpdateOutputs(2, true);
+  EXPECT_NE(kNoActions, delegate_->GetActionsAndClear());
+
+  // Clients never know state enableness for methods that they didn't request.
+  EXPECT_TRUE(
+      configurator_.EnableOutputProtection(client1,
+                                           OUTPUT_PROTECTION_METHOD_HDCP));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output,
+                                  HDCP_STATE_DESIRED).c_str(),
+            delegate_->GetActionsAndClear());
+  delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
+
+  uint32_t link_mask = 0;
+  uint32_t protection_mask = 0;
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(client1, &link_mask,
+                                                        &protection_mask));
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL | OUTPUT_TYPE_HDMI),
+            link_mask);
+  EXPECT_EQ(OUTPUT_PROTECTION_METHOD_HDCP, protection_mask);
+
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(client2, &link_mask,
+                                                        &protection_mask));
+  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL | OUTPUT_TYPE_HDMI),
+            link_mask);
+  EXPECT_EQ(OUTPUT_PROTECTION_METHOD_NONE, protection_mask);
+
+  // Protections will be disabled only if no more clients request them.
+  EXPECT_TRUE(
+      configurator_.EnableOutputProtection(client2,
+                                           OUTPUT_PROTECTION_METHOD_NONE));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output,
+                                  HDCP_STATE_DESIRED).c_str(),
+            delegate_->GetActionsAndClear());
+  EXPECT_TRUE(
+      configurator_.EnableOutputProtection(client1,
+                                           OUTPUT_PROTECTION_METHOD_NONE));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output,
+                                  HDCP_STATE_UNDESIRED).c_str(),
+            delegate_->GetActionsAndClear());
+}
+
 }  // namespace chromeos